﻿// -------------------------------------------------------------------------
//    @FileName         :    NFIMessageModule.h
//    @Author           :    Gao.Yi
//    @Date             :   2022-09-18
//    @Email			:    445267987@qq.com
//    @Module           :    NFPluginModule
//    @Description      :    消息通信模块接口定义，提供完整的网络通信、RPC服务
//                           HTTP处理、消息路由和服务器集群管理功能
//
// -------------------------------------------------------------------------

/**
 * @file NFIMessageModule.h
 * @brief 消息通信模块接口定义
 * @details 该文件定义了NFrame框架的核心消息通信接口，是整个分布式系统的通信基础：
 * 
 * 核心能力：
 * - 网络通信（TCP/UDP）和连接管理
 * - RPC服务的注册、调用和响应处理  
 * - HTTP服务器和客户端功能
 * - 服务器间的消息路由和负载均衡
 * - 事件广播和集群管理
 * - 协程支持的异步消息处理
 * 
 * 架构特点：
 * - 基于现代C++11的模板化设计
 * - 支持编译时类型检查和验证
 * - 提供同步和异步两种调用模式
 * - 协程友好的异步处理机制
 * - 高性能的零拷贝消息传递
 * 
 * 支持的通信模式：
 * - 点对点消息传递
 * - 广播和组播
 * - 请求/响应模式
 * - 发布/订阅模式
 * - 流式数据传输
 * 
 * @author Gao.Yi
 * @date 2022-09-18
 * @version 1.0
 * @see NFIServerMessageModule 服务器间通信接口
 * @see NFICoroutineModule 协程支持模块
 * @see NFIConfigModule 配置管理模块
 */

#pragma once

#include "NFComm/NFCore/NFPlatform.h"
#include "NFComm/NFPluginModule/NFIModule.h"
#include "NFComm/NFPluginModule/NFIHttpHandle.h"
#include "NFComm/NFPluginModule/NFCheck.h"
#include "google/protobuf/message.h"
#include "NFComm/NFKernelMessage/FrameSqlData.pb.h"
#include "NFICoroutineModule.h"
#include "NFServerDefine.h"
#include "NFComm/NFCore/NFCommon.h"
#include "NFIConfigModule.h"
#include "NFError.h"

#include <map>
#include <unordered_map>
#include <list>
#include <string>
#include <set>
#include <functional>

#include "NFIPacketParse.h"

class NFIDynamicModule;

/**
 * @brief 消息通信模块接口类
 * 
 * NFIMessageModule 是NFrame框架的核心通信模块，提供了完整的分布式通信解决方案：
 * 
 * 1. RPC远程过程调用：
 *    - 类型安全的RPC服务注册和调用
 *    - 同步和异步RPC支持
 *    - 脚本RPC集成
 *    - 协程化的RPC调用
 *    - 自动序列化和反序列化
 * 
 * 2. 消息处理系统：
 *    - 基于消息ID的路由机制
 *    - 模块化的消息处理
 *    - 消息回调注册和管理
 *    - 事件驱动的通信模式
 *    - 协程化的消息处理
 * 
 * 3. HTTP服务支持：
 *    - RESTful API接口
 *    - HTTP客户端和服务器
 *    - 请求过滤和中间件
 *    - 文件上传下载
 *    - 异步HTTP处理
 * 
 * 4. 服务器集群管理：
 *    - 多服务器类型支持
 *    - 服务发现和注册
 *    - 负载均衡和路由
 *    - 故障转移和恢复
 *    - 跨服务器通信
 * 
 * 5. 网络连接管理：
 *    - TCP/UDP连接池
 *    - 连接状态监控
 *    - 自动重连机制
 *    - 连接安全管理
 *    - 网络事件处理
 * 
 * 6. 数据传输优化：
 *    - Protocol Buffers序列化
 *    - 数据压缩和加密
 *    - 批量消息处理
 *    - 流量控制
 *    - 带宽优化
 * 
 * 设计特点：
 * - 高性能的异步I/O架构
 * - 类型安全的模板化接口
 * - 协程友好的调用方式
 * - 插件化的扩展机制
 * - 完善的错误处理和恢复
 * 
 * 使用场景：
 * - 分布式游戏服务器
 * - 微服务架构
 * - 实时通信系统
 * - API网关服务
 * - 物联网平台
 * 
 * 架构优势：
 * - 统一的通信抽象层
 * - 灵活的服务组合方式
 * - 高度可扩展的设计
 * - 生产级的稳定性
 */
class NFIMessageModule : public NFIModule
{
public:
    /**
     * @brief 模板化的RPC服务实现类
     * @tparam RequestType 请求消息类型，必须继承自google::protobuf::Message
     * @tparam ResponeType 响应消息类型，必须继承自google::protobuf::Message
     * 
     * NFCRpcService 提供了类型安全的RPC服务实现：
     * 
     * 核心功能：
     * - 编译时类型检查和验证
     * - 多种函数签名的支持
     * - 自动消息序列化和反序列化
     * - 协程和回调的支持
     * - 参数传递和上下文管理
     * 
     * 支持的函数签名：
     * - 基础RPC：int handler(RequestType& req, ResponeType& resp)
     * - 带连接ID：int handler(uint64_t linkId, RequestType& req, ResponeType& resp)
     * - 带参数：int handler(RequestType& req, ResponeType& resp, uint64_t p1, uint64_t p2)
     * - 带回调：int handler(RequestType& req, ResponeType& resp, std::function<void()> cb)
     * - 通用接口：int handler(uint32_t msgId, Message& req, Message& resp, uint64_t p1, uint64_t p2)
     * 
     * 设计特点：
     * - 零拷贝的消息处理
     * - 自动错误码传播
     * - 灵活的回调机制
     * - 协程无缝集成
     * 
     * 使用示例：
     * @code
     * // 定义RPC处理器
     * class UserService : public NFIDynamicModule {
     * public:
     *     int HandleLogin(LoginRequest& req, LoginResponse& resp) {
     *         // 处理登录逻辑
     *         resp.set_success(true);
     *         return 0;
     *     }
     * };
     * 
     * // 注册RPC服务
     * msgModule->AddRpcService<1001>(NF_ST_GAME, userService, &UserService::HandleLogin);
     * @endcode
     */
    template <typename RequestType, typename ResponeType>
    class NFCRpcService : public NFIRpcService
    {
        /// @brief 编译时检查：确保RequestType继承自google::protobuf::Message
        static_assert((TIsDerived<RequestType, google::protobuf::Message>::Result), "the class RequestType must is google::protobuf::Message");
        /// @brief 编译时检查：确保ResponeType继承自google::protobuf::Message
        static_assert((TIsDerived<ResponeType, google::protobuf::Message>::Result), "the class ResponeType must is google::protobuf::Message");

    public:
        /**
         * @brief 构造函数 - 支持带连接ID的成员函数
         * @tparam BaseType 服务类型，必须继承自NFIDynamicModule
         * @param p 插件管理器指针
         * @param pBase 服务对象指针
         * @param handleRecieve 成员函数指针，处理RPC调用
         */
        template <typename BaseType>
        NFCRpcService(NFIPluginManager* p, BaseType* pBase, int (BaseType::*handleRecieve)(uint64_t unLinkId, RequestType& request, ResponeType& respone)) : NFIRpcService(p)
        {
            static_assert((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
            m_functionWithLink = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
        }

        /**
         * @brief 构造函数 - 支持基础成员函数
         * @tparam BaseType 服务类型，必须继承自NFIDynamicModule
         * @param p 插件管理器指针
         * @param pBase 服务对象指针
         * @param handleRecieve 成员函数指针，基础RPC处理
         */
        template <typename BaseType>
        NFCRpcService(NFIPluginManager* p, BaseType* pBase, int (BaseType::*handleRecieve)(RequestType& request, ResponeType& respone)) : NFIRpcService(p)
        {
            static_assert((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
            m_function = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2);
        }

        /**
         * @brief 构造函数 - 支持带回调的成员函数
         * @tparam BaseType 服务类型，必须继承自NFIDynamicModule
         * @param p 插件管理器指针
         * @param pBase 服务对象指针
         * @param handleRecieve 成员函数指针，支持异步回调的RPC处理
         */
        template <typename BaseType>
        NFCRpcService(NFIPluginManager* p, BaseType* pBase, int (BaseType::*handleRecieve)(RequestType& request, ResponeType& respone, const std::function<void()>& cb)) : NFIRpcService(p)
        {
            static_assert((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
            m_functionWithCallBack = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
        }

        /**
         * @brief 构造函数 - 支持通用消息处理的成员函数
         * @tparam BaseType 服务类型，必须继承自NFIDynamicModule
         * @param p 插件管理器指针
         * @param pBase 服务对象指针
         * @param handleRecieve 成员函数指针，通用消息处理接口
         */
        template <typename BaseType>
        NFCRpcService(NFIPluginManager* p, BaseType* pBase, int (BaseType::*handleRecieve)(uint32_t msgId, google::protobuf::Message& request, google::protobuf::Message& respone, uint64_t param1, uint64_t param2)) : NFIRpcService(p)
        {
            static_assert((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
            m_functionCommonWithParam = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5);
        }

        /**
         * @brief 构造函数 - 支持带参数的成员函数
         * @tparam BaseType 服务类型，必须继承自NFIDynamicModule
         * @param p 插件管理器指针
         * @param pBase 服务对象指针
         * @param handleRecieve 成员函数指针，支持额外参数传递的RPC处理
         */
        template <typename BaseType>
        NFCRpcService(NFIPluginManager* p, BaseType* pBase, int (BaseType::*handleRecieve)(RequestType& request, ResponeType& respone, uint64_t param1, uint64_t param2)) : NFIRpcService(p)
        {
            static_assert((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
            m_functionWithParam = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
        }

        /**
         * @brief 构造函数 - 支持带连接ID的静态函数
         * @param p 插件管理器指针
         * @param handleRecieve 静态函数指针，处理RPC调用
         */
        NFCRpcService(NFIPluginManager* p, int (*handleRecieve)(uint64_t unLinkId, RequestType& request, ResponeType& respone)) : NFIRpcService(p)
        {
            m_functionWithLink = std::bind(handleRecieve, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
        }

        /**
         * @brief 构造函数 - 支持基础静态函数
         * @param p 插件管理器指针
         * @param handleRecieve 静态函数指针，基础RPC处理
         */
        NFCRpcService(NFIPluginManager* p, int (*handleRecieve)(RequestType& request, ResponeType& respone)) : NFIRpcService(p)
        {
            m_function = std::bind(handleRecieve, std::placeholders::_1, std::placeholders::_2);
        }

        /**
         * @brief 构造函数 - 支持带回调的静态函数
         * @param p 插件管理器指针
         * @param handleRecieve 静态函数指针，支持异步回调的RPC处理
         */
        NFCRpcService(NFIPluginManager* p, int (*handleRecieve)(RequestType& request, ResponeType& respone, const std::function<void()>& cb)) : NFIRpcService(p)
        {
            m_functionWithCallBack = std::bind(handleRecieve, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
        }

        /**
         * @brief 构造函数 - 支持通用消息处理的静态函数
         * @param p 插件管理器指针
         * @param handleRecieve 静态函数指针，通用消息处理接口
         */
        NFCRpcService(NFIPluginManager* p, int (*handleRecieve)(uint32_t msgId, google::protobuf::Message& request, google::protobuf::Message& respone, uint64_t param1, uint64_t param2)) : NFIRpcService(p)
        {
            m_functionCommonWithParam = std::bind(handleRecieve, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5);
        }

        /**
         * @brief 构造函数 - 支持带参数的静态函数
         * @param p 插件管理器指针
         * @param handleRecieve 静态函数指针，支持额外参数传递的RPC处理
         */
        NFCRpcService(NFIPluginManager* p, int (*handleRecieve)(RequestType& request, ResponeType& respone, uint64_t param1, uint64_t param2)) : NFIRpcService(p)
        {
            m_functionWithParam = std::bind(handleRecieve, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
        }

        /**
 * @brief 执行RPC服务处理
 * @param unLinkId 网络连接ID，用于标识发起请求的客户端
 * @param reqSvrPkg 请求数据包，包含序列化的请求消息和RPC元数据
 * @param param1 自定义参数1，可用于传递上下文信息
 * @param param2 自定义参数2，可用于传递上下文信息
 * @return 执行结果，0表示成功，非零值表示具体的错误码
 *
 * @details 这是RPC服务的核心执行方法，执行以下关键步骤：
 *
 * 1. **类型安全验证**：
 *    - 验证请求消息的类型哈希是否匹配
 *    - 验证响应消息的类型哈希是否匹配
 *    - 防止类型不匹配导致的运行时错误
 *
 * 2. **消息处理流程**：
 *    - 反序列化请求消息到强类型对象
 *    - 提取服务器类型和总线ID信息
 *    - 调用对应的处理函数
 *    - 序列化响应消息
 *
 * 3. **错误处理机制**：
 *    - 捕获并记录处理过程中的错误
 *    - 设置相应的错误码到响应消息
 *    - 确保即使出错也能返回响应
 *
 * 4. **响应消息构建**：
 *    - 构建完整的响应数据包
 *    - 包含RPC元数据（请求ID、类型哈希等）
 *    - 发送响应到原始请求方
 *
 * @note 该方法是线程安全的，可以在多线程环境中并发调用
 * @warning 处理函数内部不应抛出异常，否则可能导致响应丢失
 */
        int run(uint64_t unLinkId, const NFrame::Proto_FramePkg& reqSvrPkg, uint64_t param1, uint64_t param2) override
        {
            RequestType req;
            ResponeType rsp;
            CHECK_EXPR(NFHash::hash<std::string>()(req.GetTypeName()) == reqSvrPkg.rpc_info().req_rpc_hash(), NFrame::ERR_CODE_RPC_DECODE_FAILED, "NFCRpcService reqHash Not Equal:{}, nMsgId:{}", req.GetTypeName(), reqSvrPkg.msg_id());
            CHECK_EXPR(NFHash::hash<std::string>()(rsp.GetTypeName()) == reqSvrPkg.rpc_info().rsp_rpc_hash(), NFrame::ERR_CODE_RPC_DECODE_FAILED, "NFCRpcService rspHash Not Equal:{}, nMsgId:{}", rsp.GetTypeName(), reqSvrPkg.msg_id());

            req.ParsePartialFromString(reqSvrPkg.msg_data());

            uint32_t eServerType = GetServerTypeFromUnlinkId(unLinkId);
            uint32_t reqBusId = reqSvrPkg.rpc_info().req_bus_id();
            uint32_t reqServerType = reqSvrPkg.rpc_info().req_server_type();

            int iRet = 0;
            NFrame::Proto_FramePkg svrPkg;
            svrPkg.set_msg_id(reqSvrPkg.msg_id());
            svrPkg.mutable_rpc_info()->set_req_rpc_id(0);
            svrPkg.mutable_rpc_info()->set_rsp_rpc_id(reqSvrPkg.rpc_info().req_rpc_id());
            svrPkg.mutable_rpc_info()->set_req_rpc_hash(reqSvrPkg.rpc_info().req_rpc_hash());
            svrPkg.mutable_rpc_info()->set_rsp_rpc_hash(reqSvrPkg.rpc_info().rsp_rpc_hash());
            svrPkg.mutable_rpc_info()->set_is_script_rpc(reqSvrPkg.rpc_info().is_script_rpc());
            if (m_function || m_functionWithParam || m_functionCommonWithParam || m_functionWithLink || m_functionWithCallBack)
            {
                if (m_function)
                {
                    iRet = m_function(req, rsp);
                }
                else if (m_functionCommonWithParam)
                {
                    iRet = m_functionCommonWithParam(reqSvrPkg.msg_id(), req, rsp, param1, param2);
                }
                else if (m_functionWithParam)
                {
                    iRet = m_functionWithParam(req, rsp, param1, param2);
                }
                else if (m_functionWithLink)
                {
                    iRet = m_functionWithLink(unLinkId, req, rsp);
                }
                else if (m_functionWithCallBack)
                {
                    iRet = m_functionWithCallBack(req, rsp, [eServerType, reqServerType, reqBusId, &svrPkg, &rsp, this]()
                    {
                        svrPkg.set_msg_data(rsp.SerializePartialAsString());
                        svrPkg.mutable_rpc_info()->set_rpc_ret_code(0);
                        FindModule<NFIMessageModule>()->SendMsgToServer((NF_SERVER_TYPE)eServerType, (NF_SERVER_TYPE)reqServerType, 0, reqBusId, NF_MODULE_FRAME, NFrame::NF_SERVER_TO_SERVER_RPC_CMD, svrPkg, 0);
                    });
                }
                svrPkg.set_msg_data(rsp.SerializePartialAsString());
                svrPkg.mutable_rpc_info()->set_rpc_ret_code(iRet);
            }
            else
            {
                svrPkg.mutable_rpc_info()->set_rpc_ret_code(NFrame::ERR_CODE_RPC_MSG_FUNCTION_UNEXISTED);
            }

            FindModule<NFIMessageModule>()->SendMsgToServer((NF_SERVER_TYPE)eServerType, (NF_SERVER_TYPE)reqServerType, 0, reqBusId, NF_MODULE_FRAME, NFrame::NF_SERVER_TO_SERVER_RPC_CMD, svrPkg, 0);

            return 0;
        }

        std::function<int(RequestType& request, ResponeType& respone)> m_function; ///< 基础RPC处理函数
        std::function<int(uint32_t msgId, google::protobuf::Message& request, google::protobuf::Message& respone, uint64_t param1, uint64_t param2)> m_functionCommonWithParam; ///< 通用消息处理函数
        std::function<int(RequestType& request, ResponeType& respone, uint64_t param1, uint64_t param2)> m_functionWithParam; ///< 带参数的RPC处理函数
        std::function<int(uint64_t unLinkId, RequestType& request, ResponeType& respone)> m_functionWithLink; ///< 带连接ID的RPC处理函数
        std::function<int(RequestType& request, ResponeType& respone, const std::function<void()>& cb)> m_functionWithCallBack; ///< 带回调的RPC处理函数
    };

public:
    /**
     * @brief 脚本RPC服务实现类
     * @tparam BaseType 服务类型，必须继承自NFIDynamicModule
     *
     * NFCScriptRpcService 专门为脚本语言集成设计的RPC服务：
     *
     * 核心功能：
     * - 支持动态类型的消息处理
     * - 字符串形式的消息序列化
     * - 脚本语言友好的接口
     * - 运行时类型检查
     * - 灵活的消息格式支持
     *
     * 设计特点：
     * - 无需编译时类型绑定
     * - 支持动态消息创建
     * - 适配各种脚本语言
     * - 简化的接口设计
     *
     * 使用场景：
     * - Lua脚本RPC调用
     * - Python脚本集成
     * - 动态配置的RPC服务
     * - 热更新的业务逻辑
     */
    template <typename BaseType>
    class NFCScriptRpcService : public NFIRpcService
    {
        /// @brief 编译时检查：确保BaseType继承自NFIDynamicModule
        static_assert((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");

    public:
        /**
         * @brief 构造函数 - 支持带连接ID的脚本RPC处理
         * @param p 插件管理器指针
         * @param reqType 请求消息类型名称
         * @param rspType 响应消息类型名称
         * @param pBase 服务对象指针
         * @param handleRecieve 成员函数指针，处理脚本RPC调用
         */
        NFCScriptRpcService(NFIPluginManager* p, const std::string& reqType, const std::string& rspType, BaseType* pBase,
                            int (BaseType::*handleRecieve)(uint64_t unLinkId, uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType, std::string& respone)) : NFIRpcService(p)
        {
            m_reqType = reqType;
            m_rspType = rspType;
            m_functionWithLink = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6);
        }

        /**
         * @brief 构造函数 - 支持基础脚本RPC处理
         * @param p 插件管理器指针
         * @param reqType 请求消息类型名称
         * @param rspType 响应消息类型名称
         * @param pBase 服务对象指针
         * @param handleRecieve 成员函数指针，基础脚本RPC处理
         */
        NFCScriptRpcService(NFIPluginManager* p, const std::string& reqType, const std::string& rspType, BaseType* pBase, int (BaseType::*handleRecieve)(uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType, std::string& respone)) : NFIRpcService(p)
        {
            m_reqType = reqType;
            m_rspType = rspType;
            m_function = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5);
        }

        /**
         * @brief 构造函数 - 支持带回调的脚本RPC处理
         * @param p 插件管理器指针
         * @param reqType 请求消息类型名称
         * @param rspType 响应消息类型名称
         * @param pBase 服务对象指针
         * @param handleRecieve 成员函数指针，支持异步回调的脚本RPC处理
         */
        NFCScriptRpcService(NFIPluginManager* p, const std::string& reqType, const std::string& rspType, BaseType* pBase,
                            int (BaseType::*handleRecieve)(uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType, std::string& respone, const std::function<void()>& cb)) : NFIRpcService(p)
        {
            m_reqType = reqType;
            m_rspType = rspType;
            m_functionWithCallBack = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6);
        }

        /**
         * @brief 执行脚本RPC服务处理
         * @param unLinkId 网络连接ID
         * @param reqSvrPkg 请求数据包
         * @param param1 自定义参数1
         * @param param2 自定义参数2
         * @return 执行结果，0表示成功
         *
         * 脚本RPC的核心执行方法，负责：
         * - 动态类型验证和哈希检查
         * - 字符串形式的消息处理
         * - 调用脚本处理函数
         * - 响应消息的组装和发送
         */
        virtual int run(uint64_t unLinkId, const NFrame::Proto_FramePkg& reqSvrPkg, uint64_t param1, uint64_t param2) override
        {
            CHECK_EXPR(NFHash::hash<std::string>()(m_reqType) == reqSvrPkg.rpc_info().req_rpc_hash(), NFrame::ERR_CODE_RPC_DECODE_FAILED, "NFCScriptRpcService reqHash Not Equal:{}, nMsgId:{}", m_reqType, reqSvrPkg.msg_id());
            CHECK_EXPR(NFHash::hash<std::string>()(m_rspType) == reqSvrPkg.rpc_info().rsp_rpc_hash(), NFrame::ERR_CODE_RPC_DECODE_FAILED, "NFCScriptRpcService rspHash Not Equal:{}, nMsgId:{}", m_rspType, reqSvrPkg.msg_id());

            uint32_t eServerType = GetServerTypeFromUnlinkId(unLinkId);
            uint32_t reqBusId = reqSvrPkg.rpc_info().req_bus_id();
            uint32_t reqServerType = reqSvrPkg.rpc_info().req_server_type();

            int iRet = 0;
            NFrame::Proto_FramePkg svrPkg;
            svrPkg.set_msg_id(reqSvrPkg.msg_id());
            svrPkg.mutable_rpc_info()->set_req_rpc_id(0);
            svrPkg.mutable_rpc_info()->set_rsp_rpc_id(reqSvrPkg.rpc_info().req_rpc_id());
            svrPkg.mutable_rpc_info()->set_req_rpc_hash(reqSvrPkg.rpc_info().req_rpc_hash());
            svrPkg.mutable_rpc_info()->set_rsp_rpc_hash(reqSvrPkg.rpc_info().rsp_rpc_hash());
            svrPkg.mutable_rpc_info()->set_is_script_rpc(reqSvrPkg.rpc_info().is_script_rpc());
            if (m_function || m_functionWithLink || m_functionWithCallBack)
            {
                std::string rsp;
                if (m_function)
                {
                    iRet = m_function(reqSvrPkg.msg_id(), m_reqType, reqSvrPkg.msg_data(), m_rspType, rsp);
                }
                else if (m_functionWithLink)
                {
                    iRet = m_functionWithLink(unLinkId, reqSvrPkg.msg_id(), m_reqType, reqSvrPkg.msg_data(), m_rspType, rsp);
                }
                else if (m_functionWithCallBack)
                {
                    iRet = m_functionWithCallBack(reqSvrPkg.msg_id(), m_reqType, reqSvrPkg.msg_data(), m_rspType, rsp, [eServerType, reqServerType, reqBusId, &svrPkg, &rsp, this]()
                    {
                        svrPkg.set_msg_data(rsp);
                        svrPkg.mutable_rpc_info()->set_rpc_ret_code(0);
                        FindModule<NFIMessageModule>()->SendMsgToServer((NF_SERVER_TYPE)eServerType, (NF_SERVER_TYPE)reqServerType, 0, reqBusId, NF_MODULE_FRAME, NFrame::NF_SERVER_TO_SERVER_RPC_CMD, svrPkg, 0);
                    });
                }
                svrPkg.set_msg_data(rsp);
                svrPkg.mutable_rpc_info()->set_rpc_ret_code(iRet);
            }
            else
            {
                svrPkg.mutable_rpc_info()->set_rpc_ret_code(NFrame::ERR_CODE_RPC_MSG_FUNCTION_UNEXISTED);
            }

            FindModule<NFIMessageModule>()->SendMsgToServer((NF_SERVER_TYPE)eServerType, (NF_SERVER_TYPE)reqServerType, 0, reqBusId, NF_MODULE_FRAME, NFrame::NF_SERVER_TO_SERVER_RPC_CMD, svrPkg, 0);

            return 0;
        }

        std::string m_reqType; ///< 请求消息类型名称
        std::string m_rspType; ///< 响应消息类型名称
        std::function<int(uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType, std::string& respone)> m_function; ///< 基础脚本RPC处理函数
        std::function<int(uint64_t unLinkId, uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType, std::string& respone)> m_functionWithLink; ///< 带连接ID的脚本RPC处理函数
        std::function<int(uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType, std::string& respone, const std::function<void()>& cb)> m_functionWithCallBack; ///< 带回调的脚本RPC处理函数
    };

public:
    /**
     * @brief 构造函数
     * @param p 插件管理器指针
     *
     * 初始化消息模块，设置基础配置和状态。
     */
    NFIMessageModule(NFIPluginManager* p) : NFIModule(p)
    {
    }

    /**
     * @brief 析构函数
     *
     * 清理消息模块资源，关闭连接和释放内存。
     */
    ~NFIMessageModule() override
    {
    }

public:
    // HTTP请求处理器注册相关方法

    /**
     * @brief 添加HTTP请求处理器（指定路径）
     * @tparam BaseType 处理器类型，必须继承自合适的基类
     * @param serverType 服务器类型
     * @param strPath HTTP路径
     * @param eRequestType HTTP请求类型（GET、POST等）
     * @param pBase 处理器对象指针
     * @param handleRecieve 处理函数指针
     * @return 注册成功返回true，失败返回false
     *
     * 为指定的HTTP路径注册处理器，支持RESTful API设计。
     */
    template <typename BaseType>
    bool AddHttpRequestHandler(NF_SERVER_TYPE serverType, const std::string& strPath, const NFHttpType eRequestType, BaseType* pBase, bool (BaseType::*handleRecieve)(uint32_t, const NFIHttpHandle& req))
    {
        HTTP_RECEIVE_FUNCTOR functor = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2);
        return AddHttpMsgCB(serverType, strPath, eRequestType, functor);
    }

    /**
     * @brief 添加HTTP请求处理器（默认处理器）
     * @tparam BaseType 处理器类型
     * @param serverType 服务器类型
     * @param eRequestType HTTP请求类型
     * @param pBase 处理器对象指针
     * @param handleRecieve 处理函数指针
     * @return 注册成功返回true，失败返回false
     *
     * 为指定请求类型注册默认处理器，处理未匹配路径的请求。
     */
    template <typename BaseType>
    bool AddHttpRequestHandler(NF_SERVER_TYPE serverType, const NFHttpType eRequestType, BaseType* pBase, bool (BaseType::*handleRecieve)(uint32_t, const NFIHttpHandle& req))
    {
        HTTP_RECEIVE_FUNCTOR functor = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2);
        return AddHttpOtherMsgCB(serverType, eRequestType, functor);
    }

    /**
     * @brief 添加HTTP网络过滤器
     * @tparam BaseType 过滤器类型
     * @param serverType 服务器类型
     * @param strPath HTTP路径
     * @param pBase 过滤器对象指针
     * @param handleFilter 过滤函数指针
     * @return 注册成功返回true，失败返回false
     *
     * 为指定路径添加请求过滤器，用于认证、限流等中间件功能。
     */
    template <typename BaseType>
    bool AddHttpNetFilter(NF_SERVER_TYPE serverType, const std::string& strPath, BaseType* pBase, NFWebStatus (BaseType::*handleFilter)(uint32_t, const NFIHttpHandle& req))
    {
        HTTP_FILTER_FUNCTOR functor = std::bind(handleFilter, pBase, std::placeholders::_1, std::placeholders::_2);

        return AddHttpFilterCB(serverType, strPath, functor);
    }

public:
    // 消息回调注册相关方法

    /**
     * @brief 添加消息回调处理器
     * @tparam BaseType 处理器类型，必须继承自NFIDynamicModule
     * @param eType 服务器类型
     * @param nMsgID 消息ID
     * @param pBase 处理器对象指针
     * @param handleRecieve 处理函数指针
     * @param createCo 是否创建协程处理，默认false
     * @return 注册成功返回true，失败返回false
     *
     * 为指定消息ID注册处理器，支持协程化的异步处理。
     */
    template <typename BaseType>
    bool AddMessageCallBack(NF_SERVER_TYPE eType, uint32_t nMsgID, BaseType* pBase, int (BaseType::*handleRecieve)(uint64_t unLinkId, NFDataPackage& packet), bool createCo = false)
    {
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NET_RECEIVE_FUNCTOR functor = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2);
        return AddMessageCallBack(eType, nMsgID, pBase, functor, createCo);
    }

    /**
     * @brief 添加模块化消息回调处理器
     * @tparam BaseType 处理器类型，必须继承自NFIDynamicModule
     * @param eType 服务器类型
     * @param nModuleId 模块ID
     * @param nMsgID 消息ID
     * @param pBase 处理器对象指针
     * @param handleRecieve 处理函数指针
     * @param createCo 是否创建协程处理，默认false
     * @return 注册成功返回true，失败返回false
     *
     * 为指定模块和消息ID注册处理器，支持模块化的消息处理。
     */
    template <typename BaseType>
    bool AddMessageCallBack(NF_SERVER_TYPE eType, uint32_t nModuleId, uint32_t nMsgID, BaseType* pBase, int (BaseType::*handleRecieve)(uint64_t unLinkId, NFDataPackage& packet), bool createCo = false)
    {
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NET_RECEIVE_FUNCTOR functor = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2);
        return AddMessageCallBack(eType, nModuleId, nMsgID, pBase, functor, createCo);
    }

    /**
     * @brief 添加静态函数消息回调处理器
     * @param eType 服务器类型
     * @param nMsgID 消息ID
     * @param handleRecieve 静态处理函数指针
     * @param createCo 是否创建协程处理，默认false
     * @return 注册成功返回true，失败返回false
     */
    bool AddMessageCallBack(NF_SERVER_TYPE eType, uint32_t nMsgID, int (*handleRecieve)(uint64_t unLinkId, NFDataPackage& packet), bool createCo = false)
    {
        NET_RECEIVE_FUNCTOR functor = std::bind(handleRecieve, std::placeholders::_1, std::placeholders::_2);
        return AddMessageCallBack(eType, nMsgID, functor, createCo);
    }

    /**
     * @brief 添加模块化静态函数消息回调处理器
     * @param eType 服务器类型
     * @param nModuleId 模块ID
     * @param nMsgID 消息ID
     * @param handleRecieve 静态处理函数指针
     * @param createCo 是否创建协程处理，默认false
     * @return 注册成功返回true，失败返回false
     */
    bool AddMessageCallBack(NF_SERVER_TYPE eType, uint32_t nModuleId, uint32_t nMsgID, int (*handleRecieve)(uint64_t unLinkId, NFDataPackage& packet), bool createCo = false)
    {
        NET_RECEIVE_FUNCTOR functor = std::bind(handleRecieve, std::placeholders::_1, std::placeholders::_2);
        return AddMessageCallBack(eType, nModuleId, nMsgID, functor, createCo);
    }

    /**
     * @brief 添加其他消息回调处理器
     * @tparam BaseType 处理器类型，必须继承自NFIDynamicModule
     * @param eType 服务器类型
     * @param linkId 连接ID
     * @param pBase 处理器对象指针
     * @param handleRecieve 处理函数指针
     * @param createCo 是否创建协程处理，默认false
     * @return 注册成功返回true，失败返回false
     *
     * 为未注册的消息添加通用处理器。
     */
    template <typename BaseType>
    bool AddOtherCallBack(NF_SERVER_TYPE eType, uint64_t linkId, BaseType* pBase, int (BaseType::*handleRecieve)(uint64_t unLinkId, NFDataPackage& packet), bool createCo = false)
    {
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NET_RECEIVE_FUNCTOR functor = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2);

        return AddOtherCallBack(eType, linkId, pBase, functor, createCo);
    }

    /**
     * @brief 添加事件回调处理器
     * @tparam BaseType 处理器类型，必须继承自NFIDynamicModule
     * @param eType 服务器类型
     * @param linkId 连接ID
     * @param pBase 处理器对象指针
     * @param handler 事件处理函数指针
     * @param createCo 是否创建协程处理，默认false
     * @return 注册成功返回true，失败返回false
     *
     * 为网络事件（连接、断开等）添加处理器。
     */
    template <typename BaseType>
    bool AddEventCallBack(NF_SERVER_TYPE eType, uint64_t linkId, BaseType* pBase, int (BaseType::*handler)(eMsgType nEvent, uint64_t unLinkId), bool createCo = false)
    {
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIMessageProcessor");
        NET_EVENT_FUNCTOR functor = std::bind(handler, pBase, std::placeholders::_1, std::placeholders::_2);
        return AddEventCallBack(eType, linkId, pBase, functor, createCo);
    }

    /**
     * @brief 添加全局消息回调处理器
     * @tparam BaseType 处理器类型，必须继承自NFIDynamicModule
     * @param eType 服务器类型
     * @param pBase 处理器对象指针
     * @param handleRecieve 处理函数指针
     * @param createCo 是否创建协程处理，默认false
     * @return 注册成功返回true，失败返回false
     *
     * 对所有消息添加统一回调，通过返回值决定是否处理消息：
     * - 返回0：处理该消息
     * - 返回非0：不处理该消息
     */
    template <typename BaseType>
    bool AddAllMsgCallBack(NF_SERVER_TYPE eType, BaseType* pBase, int (BaseType::*handleRecieve)(uint64_t unLinkId, NFDataPackage& packet), bool createCo = false)
    {
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NET_RECEIVE_FUNCTOR functor = std::bind(handleRecieve, pBase, std::placeholders::_1, std::placeholders::_2);

        return AddAllMsgCallBack(eType, pBase, functor, createCo);
    }

public:
    // ========================================================================
    // RPC服务注册接口 - 成员函数版本
    // ========================================================================

    /**
     * @brief 添加RPC服务（成员函数版本 - 带连接ID）
     * @tparam msgId 消息ID，编译时常量
     * @tparam BaseType 服务类型，必须继承自NFIDynamicModule
     * @tparam RequestType 请求消息类型，必须继承自google::protobuf::Message
     * @tparam ResponeType 响应消息类型，必须继承自google::protobuf::Message
     * @param serverType 服务器类型
     * @param pBase 服务对象指针
     * @param handleRecieve 成员函数指针，处理函数签名：int (T::*)(uint64_t linkId, RequestType&, ResponeType&)
     * @param createCo 是否创建协程处理，默认false
     * @return 注册成功返回true，失败返回false
     *
     * 注册一个RPC服务处理器，处理函数可以访问网络连接ID。
     * 编译时进行类型检查，确保消息类型的正确性。
     */
    template <size_t msgId, typename BaseType, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, BaseType* pBase, int (BaseType::*handleRecieve)(uint64_t unLinkId, RequestType& request, ResponeType& respone), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, pBase, handleRecieve);
        return AddRpcService(serverType, msgId, pBase, pRpcService, createCo);
    }

    /**
     * @brief 添加RPC服务（成员函数版本 - 带模块ID和连接ID）
     * @tparam moduleId 模块ID，编译时常量
     * @tparam msgId 消息ID，编译时常量
     * @tparam BaseType 服务类型，必须继承自NFIDynamicModule
     * @tparam RequestType 请求消息类型
     * @tparam ResponeType 响应消息类型
     * @param serverType 服务器类型
     * @param pBase 服务对象指针
     * @param handleRecieve 成员函数指针
     * @param createCo 是否创建协程处理
     * @return 注册成功返回true，失败返回false
     *
     * 支持模块化的RPC服务注册，允许同一消息ID在不同模块中有不同的处理器。
     */
    template <size_t moduleId, size_t msgId, typename BaseType, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, BaseType* pBase, int (BaseType::*handleRecieve)(uint64_t unLinkId, RequestType& request, ResponeType& respone), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, pBase, handleRecieve);
        return AddRpcService(serverType, moduleId, msgId, pBase, pRpcService, createCo);
    }

    template <size_t msgId, typename BaseType, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, BaseType* pBase, int (BaseType::*handleRecieve)(RequestType& request, ResponeType& respone), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, pBase, handleRecieve);
        return AddRpcService(serverType, msgId, pBase, pRpcService, createCo);
    }

    template <size_t moduleId, size_t msgId, typename BaseType, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, BaseType* pBase, int (BaseType::*handleRecieve)(RequestType& request, ResponeType& respone), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, pBase, handleRecieve);
        return AddRpcService(serverType, moduleId, msgId, pBase, pRpcService, createCo);
    }

    template <size_t msgId, typename BaseType, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, BaseType* pBase, int (BaseType::*handleRecieve)(uint32_t msg, google::protobuf::Message& request, google::protobuf::Message& respone, uint64_t param1, uint64_t param2), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, pBase, handleRecieve);
        return AddRpcService(serverType, msgId, pBase, pRpcService, createCo);
    }

    template <size_t moduleId, size_t msgId, typename BaseType, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, BaseType* pBase, int (BaseType::*handleRecieve)(uint32_t msg, google::protobuf::Message& request, google::protobuf::Message& respone, uint64_t param1, uint64_t param2), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, pBase, handleRecieve);
        return AddRpcService(serverType, moduleId, msgId, pBase, pRpcService, createCo);
    }

    template <size_t msgId, typename BaseType, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, BaseType* pBase, int (BaseType::*handleRecieve)(RequestType& request, ResponeType& respone, uint64_t param1, uint64_t param2), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, pBase, handleRecieve);
        return AddRpcService(serverType, msgId, pBase, pRpcService, createCo);
    }

    template <size_t moduleId, size_t msgId, typename BaseType, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, BaseType* pBase, int (BaseType::*handleRecieve)(RequestType& request, ResponeType& respone, uint64_t param1, uint64_t param2), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, pBase, handleRecieve);
        return AddRpcService(serverType, moduleId, msgId, pBase, pRpcService, createCo);
    }

    template <size_t msgId, typename BaseType, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, BaseType* pBase, int (BaseType::*handleRecieve)(RequestType& request, ResponeType& respone, const std::function<void()>& cb), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, pBase, handleRecieve);
        return AddRpcService(serverType, msgId, pBase, pRpcService, createCo);
    }

    template <size_t moduleId, size_t msgId, typename BaseType, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, BaseType* pBase, int (BaseType::*handleRecieve)(RequestType& request, ResponeType& respone, const std::function<void()>& cb), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, pBase, handleRecieve);
        return AddRpcService(serverType, moduleId, msgId, pBase, pRpcService, createCo);
    }

public:
    // ========================================================================
    // RPC服务注册接口 - 静态函数版本
    // ========================================================================

    /**
     * @brief 添加RPC服务（静态函数版本 - 带连接ID）
     * @tparam msgId 消息ID，编译时常量
     * @tparam RequestType 请求消息类型，必须继承自google::protobuf::Message
     * @tparam ResponeType 响应消息类型，必须继承自google::protobuf::Message
     * @param serverType 服务器类型
     * @param handleRecieve 静态函数指针，处理函数签名：int (*)(uint64_t, RequestType&, ResponeType&)
     * @param createCo 是否创建协程处理，默认false
     * @return 注册成功返回true，失败返回false
     *
     * 使用静态函数注册RPC服务，不需要关联特定的对象实例。
     * 适用于无状态的服务处理逻辑。
     */
    template <size_t msgId, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, int (*handleRecieve)(uint64_t unLinkId, RequestType& request, ResponeType& respone), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, handleRecieve);
        return AddRpcService(serverType, msgId, pRpcService, createCo);
    }

    template <size_t moduleId, size_t msgId, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, int (*handleRecieve)(uint64_t unLinkId, RequestType& request, ResponeType& respone), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, handleRecieve);
        return AddRpcService(serverType, moduleId, msgId, pRpcService, createCo);
    }

    template <size_t msgId, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, int (*handleRecieve)(RequestType& request, ResponeType& respone), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, handleRecieve);
        return AddRpcService(serverType, msgId, pRpcService, createCo);
    }

    template <size_t moduleId, size_t msgId, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, int (*handleRecieve)(RequestType& request, ResponeType& respone), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, handleRecieve);
        return AddRpcService(serverType, moduleId, msgId, pRpcService, createCo);
    }

    template <size_t msgId, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, int (*handleRecieve)(uint32_t msg, google::protobuf::Message& request, google::protobuf::Message& respone, uint64_t param1, uint64_t param2), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, handleRecieve);
        return AddRpcService(serverType, msgId, pRpcService, createCo);
    }

    template <size_t moduleId, size_t msgId, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, int (*handleRecieve)(uint32_t msg, google::protobuf::Message& request, google::protobuf::Message& respone, uint64_t param1, uint64_t param2), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, handleRecieve);
        return AddRpcService(serverType, moduleId, msgId, pRpcService, createCo);
    }

    template <size_t msgId, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, int (*handleRecieve)(RequestType& request, ResponeType& respone, uint64_t param1, uint64_t param2), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, handleRecieve);
        return AddRpcService(serverType, msgId, pRpcService, createCo);
    }

    template <size_t moduleId, size_t msgId, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, int (*handleRecieve)(RequestType& request, ResponeType& respone, uint64_t param1, uint64_t param2), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, handleRecieve);
        return AddRpcService(serverType, moduleId, msgId, pRpcService, createCo);
    }

    template <size_t msgId, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, int (*handleRecieve)(RequestType& request, ResponeType& respone, const std::function<void()>& cb), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, handleRecieve);
        return AddRpcService(serverType, msgId, pRpcService, createCo);
    }

    template <size_t moduleId, size_t msgId, typename RequestType, typename ResponeType>
    bool AddRpcService(NF_SERVER_TYPE serverType, int (*handleRecieve)(RequestType& request, ResponeType& respone, const std::function<void()>& cb), bool createCo = false)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        NFIRpcService* pRpcService = new NFCRpcService<RequestType, ResponeType>(m_pObjPluginManager, handleRecieve);
        return AddRpcService(serverType, moduleId, msgId, pRpcService, createCo);
    }

public:
    // ========================================================================
    // 脚本RPC服务注册接口
    // ========================================================================

    /**
     * @brief 添加脚本RPC服务（带连接ID）
     * @tparam BaseType 服务类型，必须继承自NFIDynamicModule
     * @param serverType 服务器类型
     * @param nMsgId 消息ID
     * @param reqType 请求消息类型名称
     * @param rspType 响应消息类型名称
     * @param pBase 服务对象指针
     * @param handleRecieve 成员函数指针，处理函数签名：int (T::*)(uint64_t, uint32_t, string&, string&, string&, string&)
     * @param createCo 是否创建协程处理，默认false
     * @return 注册成功返回true，失败返回false
     *
     * 专为脚本语言设计的RPC服务注册，支持动态类型和字符串形式的消息处理。
     * 适用于Lua、Python等脚本语言的RPC调用。
     */
    template <typename BaseType>
    bool AddScriptRpcService(NF_SERVER_TYPE serverType, uint32_t nMsgId, const std::string& reqType, const std::string& rspType, BaseType* pBase,
                             int (BaseType::*handleRecieve)(uint64_t unLinkId, uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType, std::string& respone), bool createCo = false)
    {
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCScriptRpcService<BaseType>(m_pObjPluginManager, reqType, rspType, pBase, handleRecieve);
        return AddRpcService(serverType, nMsgId, pBase, pRpcService, createCo);
    }

    template <typename BaseType>
    bool AddScriptRpcService(NF_SERVER_TYPE serverType, uint32_t nMsgId, const std::string& reqType, const std::string& rspType, BaseType* pBase, int (BaseType::*handleRecieve)(uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType, std::string& respone),
                             bool createCo = false)
    {
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCScriptRpcService<BaseType>(m_pObjPluginManager, reqType, rspType, pBase, handleRecieve);
        return AddRpcService(serverType, nMsgId, pBase, pRpcService, createCo);
    }

    template <typename BaseType>
    bool AddScriptRpcService(NF_SERVER_TYPE serverType, uint32_t nMsgId, const std::string& reqType, const std::string& rspType, BaseType* pBase,
                             int (BaseType::*handleRecieve)(uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType, std::string& respone, const std::function<void()>& cb), bool createCo = false)
    {
        NF_ASSERT_MSG((TIsDerived<BaseType, NFIDynamicModule>::Result), "the class must inherit NFIDynamicModule");
        NFIRpcService* pRpcService = new NFCScriptRpcService<BaseType>(m_pObjPluginManager, reqType, rspType, pBase, handleRecieve);
        return AddRpcService(serverType, nMsgId, pBase, pRpcService, createCo);
    }

    // ========================================================================
    // RPC服务调用接口 - 同步版本（协程）
    // ========================================================================

    /**
     * @brief 同步RPC调用（协程版本 - 基础）
     * @tparam msgId 消息ID，编译时常量，用于唯一标识RPC服务
     * @tparam RequestType 请求消息类型，必须继承自google::protobuf::Message
     * @tparam ResponeType 响应消息类型，必须继承自google::protobuf::Message
     * @param serverType 发送方服务器类型，标识调用者的服务器类型
     * @param dstServerType 目标服务器类型，标识被调用者的服务器类型
     * @param dstBusId 目标服务器总线ID，用于精确定位目标服务器实例
     * @param request 请求消息对象，包含调用参数
     * @param respone 响应消息对象（输出参数），用于接收调用结果
     * @param param1 自定义参数1，默认为0，可用于传递额外的上下文信息
     * @param param2 自定义参数2，默认为0，可用于传递额外的上下文信息
     * @return 调用结果，0表示成功，非0表示具体的错误码
     *
     * @details 这是协程化的同步RPC调用接口，具有以下特点：
     * 
     * **执行流程**：
     * 1. **编译时验证**：验证消息类型的有效性和RPC服务绑定
     * 2. **消息准备**：构建RPC请求包，包含序列化的请求数据和元数据
     * 3. **网络发送**：通过消息模块发送RPC请求到目标服务器
     * 4. **协程挂起**：当前协程挂起，等待响应返回
     * 5. **结果处理**：接收响应后反序列化到响应对象
     * 
     * **类型安全**：
     * - 编译时检查请求和响应类型的匹配性
     * - 运行时验证消息类型哈希的一致性
     * - 防止类型转换错误和数据损坏
     * 
     * **超时处理**：
     * - 内置超时机制（DEFINE_RPC_SERVICE_TIME_OUT_MS）
     * - 超时后自动返回错误码
     * - 避免协程永久阻塞
     * 
     * **使用示例**：
     * @code
     * // 在协程内调用
     * LoginRequest req;
     * req.set_username("test");
     * LoginResponse resp;
     * 
     * int ret = msgModule->GetRpcService<1001>(NF_ST_GAME, NF_ST_LOGIN, 0, req, resp);
     * if (ret == 0) {
     *     // 处理成功响应
     *     bool success = resp.success();
     * } else {
     *     // 处理错误
     *     NFLogError("RPC call failed: {}", GetErrorStr(ret));
     * }
     * @endcode
     *
     * @warning 该方法必须在协程内部调用，否则会导致断言失败
     * @warning 调用会阻塞当前协程直到收到响应或超时
     * @note 内部使用默认模块ID（NF_MODULE_SERVER）
     * @note 支持分布式服务发现和负载均衡
     * @see GetRpcService 带模块ID的版本
     * @see NFICoroutineModule 协程管理模块
     */
    template <size_t msgId, typename RequestType, typename ResponeType>
    int GetRpcService(NF_SERVER_TYPE serverType, NF_SERVER_TYPE dstServerType, uint32_t dstBusId, const RequestType& request, ResponeType& respone, uint64_t param1 = 0, uint64_t param2 = 0)
    {
        return GetRpcService<NF_MODULE_SERVER, msgId>(serverType, dstServerType, dstBusId, request, respone, param1, param2);
    }

    /**
     * @brief 同步RPC调用（协程版本 - 带模块ID）
     * @tparam moduleId 模块ID，编译时常量
     * @tparam msgId 消息ID，编译时常量
     * @tparam RequestType 请求消息类型
     * @tparam ResponeType 响应消息类型
     * @param serverType 发送方服务器类型
     * @param dstServerType 目标服务器类型
     * @param dstBusId 目标服务器总线ID
     * @param request 请求消息对象
     * @param respone 响应消息对象（输出参数）
     * @param param1 自定义参数1，默认为0
     * @param param2 自定义参数2，默认为0
     * @return 调用结果，0表示成功，非0表示失败
     *
     * 支持模块化的同步RPC调用，允许指定目标模块ID进行精确路由。
     */
    template <size_t moduleId, size_t msgId, typename RequestType, typename ResponeType>
    int GetRpcService(NF_SERVER_TYPE serverType, NF_SERVER_TYPE dstServerType, uint32_t dstBusId, const RequestType& request, ResponeType& respone, uint64_t param1 = 0, uint64_t param2 = 0)
    {
        STATIC_ASSERT_BIND_RPC_SERVICE(msgId, RequestType, ResponeType);
        static_assert((TIsDerived<RequestType, google::protobuf::Message>::Result), "the class RequestType must is google::protobuf::Message");
        static_assert((TIsDerived<ResponeType, google::protobuf::Message>::Result), "the class ResponeType must is google::protobuf::Message");
        NF_ASSERT_MSG(FindModule<NFICoroutineModule>()->IsInCoroutine(), "Call GetRpcService Must Int the Coroutine");
        NFServerConfig* pConfig = FindModule<NFIConfigModule>()->GetAppConfig(serverType);
        CHECK_EXPR(pConfig, -1, "can't find server config! servertype:{}", GetServerName(serverType));

        NFrame::Proto_FramePkg svrPkg;
        svrPkg.set_module_id(moduleId);
        svrPkg.set_msg_id(msgId);
        svrPkg.set_msg_data(request.SerializePartialAsString());
        svrPkg.mutable_rpc_info()->set_req_rpc_id(FindModule<NFICoroutineModule>()->CurrentTaskId());
        svrPkg.mutable_rpc_info()->set_req_rpc_hash(NFHash::hash<std::string>()(request.GetTypeName()));
        svrPkg.mutable_rpc_info()->set_rsp_rpc_hash(NFHash::hash<std::string>()(respone.GetTypeName()));
        svrPkg.mutable_rpc_info()->set_req_server_type(serverType);
        svrPkg.mutable_rpc_info()->set_req_bus_id(pConfig->BusId);
        svrPkg.mutable_rpc_info()->set_is_script_rpc(false);

        SendMsgToServer(serverType, dstServerType, pConfig->BusId, dstBusId, NF_MODULE_FRAME, NFrame::NF_SERVER_TO_SERVER_RPC_CMD, svrPkg, 0, param1, param2);

        int32_t iRet = FindModule<NFICoroutineModule>()->SetUserData(&respone);
        CHECK_EXPR(iRet == 0, iRet, "Yield Failed, Error:{}", GetErrorStr(iRet));

        iRet = FindModule<NFICoroutineModule>()->Yield(DEFINE_RPC_SERVICE_TIME_OUT_MS);

        FindModule<NFICoroutineModule>()->SetUserData(nullptr);

        CHECK_EXPR(iRet == 0, iRet, "Yield Failed, Error:{} rpc Msg Id:{} request:{} respone:{}", GetErrorStr(iRet), msgId, request.GetTypeName(), respone.GetTypeName());
        return iRet;
    }

    // ========================================================================
    // RPC服务调用接口 - 异步版本（回调）
    // ========================================================================

    /**
     * @brief 异步RPC调用（回调版本 - 基础）
     * @tparam msgId 消息ID，编译时常量
     * @tparam RequestType 请求消息类型，必须继承自google::protobuf::Message
     * @tparam ResponFunc 响应回调函数类型
     * @param serverType 发送方服务器类型
     * @param dstServerType 目标服务器类型
     * @param dstBusId 目标服务器总线ID
     * @param request 请求消息对象
     * @param rpcCb 响应回调函数，签名：void(int retCode, ResponeType& response)
     * @param param1 自定义参数1，默认为0
     * @param param2 自定义参数2，默认为0
     * @param is_immediately 是否立即执行，默认true
     * @return 返回RPC请求ID，可用于取消请求；-1表示失败
     *
     * @note 该方法会自动创建协程来处理RPC调用，不能在其他协程内调用
     * @warning 不要在已有协程上下文中调用此方法，会导致协程嵌套问题
     * @details 该方法适用于非阻塞的RPC调用场景：
     *          - 自动创建独立协程处理RPC
     *          - 通过回调函数异步接收响应
     *          - 支持超时和错误处理
     *          - 可选择立即执行或延迟执行
     */
    template <size_t msgId, typename RequestType, typename ResponFunc>
    int64_t GetRpcService(NF_SERVER_TYPE serverType, NF_SERVER_TYPE dstServerType, uint32_t dstBusId, const RequestType& request, const ResponFunc& rpcCb, uint64_t param1 = 0, uint64_t param2 = 0, bool is_immediately = true)
    {
        return GetRpcServiceInner<NF_MODULE_SERVER, msgId>(serverType, dstServerType, dstBusId, request, rpcCb, &ResponFunc::operator(), param1, param2, is_immediately);
    }

    template <size_t moduleId, size_t msgId, typename RequestType, typename ResponFunc>
    int64_t GetRpcService(NF_SERVER_TYPE serverType, NF_SERVER_TYPE dstServerType, uint32_t dstBusId, const RequestType& request, const ResponFunc& rpcCb, uint64_t param1 = 0, uint64_t param2 = 0, bool is_immediately = true)
    {
        return GetRpcServiceInner<moduleId, msgId>(serverType, dstServerType, dstBusId, request, rpcCb, &ResponFunc::operator(), param1, param2, is_immediately);
    }

    int GetScriptRpcService(NF_SERVER_TYPE serverType, NF_SERVER_TYPE dstServerType, uint32_t dstBusId, uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType, std::string& respone)
    {
        NF_ASSERT_MSG(FindModule<NFICoroutineModule>()->IsInCoroutine(), "Call GetScriptRpcService Must Int the Coroutine");
        NFServerConfig* pConfig = FindModule<NFIConfigModule>()->GetAppConfig(serverType);
        CHECK_EXPR(pConfig, -1, "can't find server config! servertype:{}", GetServerName(serverType));

        NFrame::Proto_FramePkg svrPkg;
        svrPkg.set_module_id(NF_MODULE_SERVER);
        svrPkg.set_msg_id(msgId);
        svrPkg.set_msg_data(request);
        svrPkg.mutable_rpc_info()->set_req_rpc_id(FindModule<NFICoroutineModule>()->CurrentTaskId());
        svrPkg.mutable_rpc_info()->set_req_rpc_hash(NFHash::hash<std::string>()(reqType));
        svrPkg.mutable_rpc_info()->set_rsp_rpc_hash(NFHash::hash<std::string>()(rspType));
        svrPkg.mutable_rpc_info()->set_req_server_type(serverType);
        svrPkg.mutable_rpc_info()->set_req_bus_id(pConfig->BusId);
        svrPkg.mutable_rpc_info()->set_is_script_rpc(true);

        SendMsgToServer(serverType, dstServerType, pConfig->BusId, dstBusId, NF_MODULE_FRAME, NFrame::NF_SERVER_TO_SERVER_RPC_CMD, svrPkg, 0);
        NFrame::Proto_ScriptRpcResult result;
        result.set_req_type(reqType);
        result.set_rsp_type(rspType);
        int32_t iRet = FindModule<NFICoroutineModule>()->SetUserData(&result);
        CHECK_EXPR(iRet == 0, iRet, "Yield Failed, Error:{}", GetErrorStr(iRet));

        iRet = FindModule<NFICoroutineModule>()->Yield(DEFINE_RPC_SERVICE_TIME_OUT_MS);

        respone = result.respone();
        FindModule<NFICoroutineModule>()->SetUserData(nullptr);

        CHECK_EXPR(iRet == 0, iRet, "Yield Failed, Error:{}", GetErrorStr(iRet));
        return iRet;
    }

    int64_t GetScriptRpcService(NF_SERVER_TYPE serverType, NF_SERVER_TYPE dstServerType, uint32_t dstBusId, uint32_t msgId, const std::string& reqType, const std::string& request, const std::string& rspType,
                                const std::function<void(int rpcRetCode, const std::string& rspType, std::string& respone)>& func)
    {
        return FindModule<NFICoroutineModule>()->MakeCoroutine([=]()
        {
            std::string respone;
            int iRet = FindModule<NFIMessageModule>()->GetScriptRpcService(serverType, dstServerType, dstBusId, msgId, reqType, request, rspType, respone);
            if (func)
            {
                func(iRet, rspType, respone);
            }
        });
    }

private:
    /**
     * @brief 这个函数会先创建一个协程， 获取远程服务器的rpc服务，不能在别的协程里调用这个函数
     * @tparam RequestType
     * @tparam ResponeType
     * @param serverType
     * @param dstServerType
     * @param dstBusId
     * @param request
     * @param responFunc
     * @param param1
     * @param param2
     * @param is_immediately
     * @return
     */
    template <size_t moduleId, size_t msgId, typename RequestType, typename ResponFunc, typename ResponeType>
    int64_t GetRpcServiceInner(NF_SERVER_TYPE serverType, NF_SERVER_TYPE dstServerType, uint32_t dstBusId, const RequestType& request, const ResponFunc& responFunc, void (ResponFunc::*pf)(int rpcRetCode, ResponeType& respone) const, uint64_t param1 = 0, uint64_t param2 = 0,
                               bool is_immediately = true)
    {
        return FindModule<NFICoroutineModule>()->MakeCoroutine([=]()
        {
            ResponeType respone;
            int iRet = FindModule<NFIMessageModule>()->GetRpcService<moduleId, msgId>(serverType, dstServerType, dstBusId, request, respone, param1, param2);
            (responFunc.*pf)(iRet, respone);
        }, is_immediately);
    }

public:
    /**
     * @brief 添加rpc服务
     * @param serverType
     * @param nMsgID
     * @param pBase
     * @param pRpcService
     * @param createCo
     * @return
     */
    virtual bool AddRpcService(NF_SERVER_TYPE serverType, uint32_t nMsgID, NFIDynamicModule* pBase, NFIRpcService* pRpcService, bool createCo = false) = 0;

    // 添加RPC服务的接口
    // 本函数的目的是在指定的服务器类型和模块ID下注册一个新的RPC服务
    // 这个接口允许从动态模块向特定类型的服务器添加RPC服务，从而实现模块间的远程过程调用
    // 参数:
    //   serverType: 服务器类型，指定了RPC服务所属的服务器类别
    //   nModuleID: 模块ID，唯一标识了RPC服务所属的模块
    //   nMsgID: 消息ID，用于标识具体的RPC方法
    //   pBase: 指向动态模块的指针，表示添加RPC服务的动态模块
    //   pRpcService: 指向RPC服务接口的指针，用于实现RPC方法的调用
    //   createCo: 是否创建协程，用于支持异步操作，默认为false
    // 返回值:
    //   bool: 表示添加RPC服务是否成功
    virtual bool AddRpcService(NF_SERVER_TYPE serverType, uint32_t nModuleID, uint32_t nMsgID, NFIDynamicModule* pBase, NFIRpcService* pRpcService, bool createCo = false) = 0;

    virtual bool AddRpcService(NF_SERVER_TYPE serverType, uint32_t nMsgID, NFIRpcService* pRpcService, bool createCo = false) = 0;

    virtual bool AddRpcService(NF_SERVER_TYPE serverType, uint32_t nModuleID, uint32_t nMsgID, NFIRpcService* pRpcService, bool createCo = false) = 0;

public:
    /**
     * @brief 绑定服务器监听端口
     * @param eServerType 服务器类型，定义该服务器在集群中的角色
     * @param url 监听地址，格式为 "protocol://host:port"，例如 "tcp://0.0.0.0:8080"
     * @param nNetThreadNum 网络线程数量，默认为1，建议根据CPU核心数调整
     * @param nMaxConnectNum 最大连接数，默认为100，超过此数量的连接将被拒绝
     * @param nPacketParseType 数据包解析类型，默认为内部协议解析
     * @param bSecurity 是否启用安全连接（TLS/SSL），默认为false
     * @return 成功返回服务器唯一ID（非零值），失败返回0
     * 
     * @details 该方法用于启动服务器监听，支持以下特性：
     * - 多协议支持：TCP、UDP、WebSocket等
     * - 多线程网络处理，提升并发性能
     * - 连接数限制，防止资源耗尽
     * - 可选的安全连接支持
     * - 自定义数据包解析器
     * 
     * @note 每个服务器类型通常只需要绑定一次
     * @warning 确保端口未被占用，否则绑定会失败
     * @see ConnectServer 连接到其他服务器
     */
    virtual uint64_t BindServer(NF_SERVER_TYPE eServerType, const std::string& url, uint32_t nNetThreadNum = 1, uint32_t nMaxConnectNum = 100, uint32_t nPacketParseType = PACKET_PARSE_TYPE_INTERNAL, bool bSecurity = false) = 0;

    /**
     * 重置并初始化解析包。
     *
     * 本函数旨在根据指定的解析类型和解析包对象，进行重置和初始化操作，以确保数据包的解析过程正确进行。
     *
     * @param parseType 解析类型，一个无符号32位整数，用于指定解析的类型或模式。
     * @param pPacketParse 指向NFIPacketParse对象的指针，表示要进行重置和初始化的数据包对象。
     * @return 返回一个整数值，表示操作的结果，具体含义取决于实现。
     */
    virtual int ResetPacketParse(uint32_t parseType, NFIPacketParse* pPacketParse) = 0;

    /**
     * @brief 连接到远程服务器
     * @param eServerType 目标服务器类型，定义连接的目标服务器角色
     * @param url 目标服务器地址，格式为 "protocol://host:port"
     * @param nPacketParseType 数据包解析类型，默认为0（使用默认解析器）
     * @param bSecurity 是否启用安全连接（TLS/SSL），默认为false
     * @return 成功返回连接唯一ID（非零值），失败返回0
     * 
     * @details 该方法用于建立到远程服务器的连接，特性包括：
     * - 支持多种协议：TCP、UDP、WebSocket等
     * - 自动重连机制，网络中断后自动恢复
     * - 连接状态监控和事件通知
     * - 可选的安全连接支持
     * - 连接池管理，复用已有连接
     * 
     * @note 连接建立是异步的，可能需要一些时间才能完成
     * @note 同一目标地址的重复连接会被合并
     * @warning 确保目标服务器地址可达，否则连接会失败
     * @see BindServer 绑定本地监听端口
     * @see ResumeConnect 恢复连接
     */
    virtual uint64_t ConnectServer(NF_SERVER_TYPE eServerType, const std::string& url, uint32_t nPacketParseType = 0, bool bSecurity = false) = 0;

    /**
     * @brief 恢复指定服务器类型的连接
     * @param eServerType 要恢复连接的服务器类型
     * @return 执行结果：0成功，非0值表示错误码
     * 
     * @details 该方法用于恢复因网络中断或其他原因断开的服务器连接：
     * - 重新建立到指定类型服务器的所有连接
     * - 触发重连机制，自动尝试连接所有已配置的目标服务器
     * - 发送连接恢复事件通知
     * 
     * @note 通常在网络故障恢复后调用
     * @see ConnectServer 建立新连接
     */
    virtual int ResumeConnect(NF_SERVER_TYPE eServerType) = 0;

    /**
     * @brief 获取连接的IP地址
     * @param usLinkId 连接唯一标识符
     * @return 连接的IP地址字符串，连接不存在时返回空字符串
     * 
     * @details 返回指定连接的远程IP地址信息：
     * - 对于服务器连接，返回远程服务器的IP
     * - 对于客户端连接，返回客户端的IP
     * - IP地址格式为标准的点分十进制（如 "192.168.1.100"）
     * 
     * @note 可用于日志记录、安全验证和统计分析
     */
    virtual std::string GetLinkIp(uint64_t usLinkId) = 0;

    virtual bool IsExistLinkId(uint64_t linkId) = 0;

    /**
     * @brief 获取连接的端口号
     * @param usLinkId 连接唯一标识符
     * @return 连接的端口号，连接不存在时返回0
     * 
     * @details 返回指定连接的远程端口信息：
     * - 对于服务器连接，返回远程服务器的端口
     * - 对于客户端连接，返回客户端的端口
     * - 端口范围为1-65535
     * 
     * @note 通常与GetLinkIp配合使用，获取完整的连接地址信息
     */
    virtual uint32_t GetPort(uint64_t usLinkId) = 0;

    /**
     * @brief 关闭指定的网络连接
     * @param usLinkId 要关闭的连接唯一标识符
     * 
     * @details 优雅地关闭指定的网络连接：
     * - 发送关闭通知给对端
     * - 清理连接相关的资源和缓存
     * - 触发连接断开事件通知
     * - 从连接池中移除该连接
     * 
     * @note 关闭后该连接ID将不再有效
     * @warning 不要重复关闭同一连接
     * @see CloseServer 关闭服务器级别的连接
     */
    virtual void CloseLinkId(uint64_t usLinkId) = 0;

    /**
     * @brief 关闭服务器间的特定连接
     * @param eServerType 发起关闭的服务器类型
     * @param destServer 目标服务器类型
     * @param busId 目标服务器总线ID
     * @param usLinkId 要关闭的连接ID
     * 
     * @details 关闭两个特定服务器之间的连接：
     * - 基于服务器类型和总线ID精确定位连接
     * - 清理服务器间的路由信息
     * - 更新服务器状态和可用性信息
     * - 触发服务器断开事件
     * 
     * @note 该方法通常用于集群管理和故障处理
     * @see CloseLinkId 关闭普通连接
     */
    virtual void CloseServer(NF_SERVER_TYPE eServerType, NF_SERVER_TYPE destServer, uint32_t busId, uint64_t usLinkId) = 0;

    /**
     * @brief 转发数据包到指定连接
     * @param usLinkId 目标连接ID
     * @param packet 要转发的数据包
     * 
     * @details 将接收到的数据包转发到指定连接：
     * - 保持原始数据包的完整性
     * - 更新路由信息和时间戳
     * - 支持数据包的透明转发
     * - 用于实现代理和路由功能
     * 
     * @note 主要用于代理服务器的消息转发
     * @see Send 发送新构建的消息
     */
    virtual void TransPackage(uint64_t usLinkId, NFDataPackage& packet) = 0;

    /**
     * @brief 处理接收到的消息数据包
     * @param packet 接收到的数据包
     * 
     * @details 处理从网络接收到的数据包：
     * - 解析数据包头部信息
     * - 根据消息ID路由到对应的处理器
     * - 触发消息回调函数
     * - 处理协程唤醒和异步响应
     * 
     * @note 该方法通常由网络层自动调用
     * @warning 不要在业务代码中直接调用此方法
     */
    virtual void OnHandleMessage(NFDataPackage& packet) = 0;

    /**
     * @brief 发送字符串消息到指定连接
     * @param usLinkId 目标连接ID
     * @param nModuleId 模块ID，用于消息路由
     * @param nMsgID 消息ID，唯一标识消息类型
     * @param strData 消息数据（字符串格式）
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param param1 自定义参数1，默认为0
     * @param param2 自定义参数2，默认为0
     * @param srcId 源ID，标识消息发送者，默认为0
     * @param dstId 目标ID，标识消息接收者，默认为0
     * 
     * @details 发送字符串格式的消息数据：
     * - 支持任意格式的字符串数据（JSON、XML、二进制等）
     * - 自动添加消息头部信息
     * - 支持消息路由和负载均衡
     * - 提供完整的消息跟踪信息
     * 
     * @note 对于结构化数据，建议使用Protobuf版本的Send方法
     */
    virtual void Send(uint64_t usLinkId, uint32_t nModuleId, uint32_t nMsgID, const std::string& strData, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0, uint64_t srcId = 0, uint64_t dstId = 0) = 0;

    /**
     * @brief 发送二进制消息到指定连接
     * @param usLinkId 目标连接ID
     * @param nModuleId 模块ID，用于消息路由
     * @param nMsgID 消息ID，唯一标识消息类型
     * @param msg 消息数据指针
     * @param nLen 消息数据长度
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param param1 自定义参数1，默认为0
     * @param param2 自定义参数2，默认为0
     * @param srcId 源ID，标识消息发送者，默认为0
     * @param dstId 目标ID，标识消息接收者，默认为0
     * 
     * @details 发送原始二进制数据：
     * - 支持任意格式的二进制数据
     * - 零拷贝发送，性能更优
     * - 精确控制数据长度
     * - 适用于大数据量传输
     * 
     * @warning 确保msg指针在发送完成前保持有效
     * @warning 确保nLen与实际数据长度一致，避免越界访问
     */
    virtual void Send(uint64_t usLinkId, uint32_t nModuleId, uint32_t nMsgID, const char* msg, uint32_t nLen, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0, uint64_t srcId = 0, uint64_t dstId = 0) = 0;

    /**
     * @brief 发送Protobuf消息到指定连接
     * @param usLinkId 目标连接ID
     * @param nModuleId 模块ID，用于消息路由
     * @param nMsgID 消息ID，唯一标识消息类型
     * @param xData Protobuf消息对象
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param param1 自定义参数1，默认为0
     * @param param2 自定义参数2，默认为0
     * @param srcId 源ID，标识消息发送者，默认为0
     * @param dstId 目标ID，标识消息接收者，默认为0
     * 
     * @details 发送Protobuf格式的结构化消息：
     * - 自动序列化Protobuf消息
     * - 类型安全，编译时检查
     * - 支持复杂的数据结构
     * - 跨语言兼容性
     * - 高效的二进制编码
     * 
     * @note 推荐用于所有结构化数据的传输
     * @note 消息对象会被自动序列化，不需要手动处理
     */
    virtual void Send(uint64_t usLinkId, uint32_t nModuleId, uint32_t nMsgID, const google::protobuf::Message& xData, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0, uint64_t srcId = 0, uint64_t dstId = 0) = 0;

    virtual void Send(uint64_t usLinkId, uint32_t nMsgID, const std::string& strData, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0)
    {
        Send(usLinkId, NF_MODULE_SERVER, nMsgID, strData, modKey, param1, param2);
    }

    virtual void Send(uint64_t usLinkId, uint32_t nMsgID, const char* msg, uint32_t nLen, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0)
    {
        Send(usLinkId, NF_MODULE_SERVER, nMsgID, msg, nLen, modKey, param1, param2);
    }

    virtual void Send(uint64_t usLinkId, uint32_t nMsgID, const google::protobuf::Message& xData, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0)
    {
        Send(usLinkId, NF_MODULE_SERVER, nMsgID, xData, modKey, param1, param2);
    }

    /**
     * @brief 发送字符串消息到服务器
     * @param usLinkId 目标连接ID
     * @param nModuleId 模块ID，用于消息路由
     * @param nMsgID 消息ID，标识消息类型
     * @param strData 字符串消息数据
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param param1 自定义参数1，默认为0
     * @param param2 自定义参数2，默认为0
     * @param srcId 源ID，标识消息发送者，默认为0
     * @param dstId 目标ID，标识消息接收者，默认为0
     * 
     * @details 向服务器发送字符串格式的消息：
     * - 支持任意格式的字符串数据
     * - 提供完整的消息追踪信息
     * - 支持负载均衡和路由控制
     * - 适用于文本协议和JSON数据
     * 
     * @note 专门用于服务器间通信
     * @see Send 客户端消息发送
     */
    virtual void SendServer(uint64_t usLinkId, uint32_t nModuleId, uint32_t nMsgID, const std::string& strData, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0, uint64_t srcId = 0, uint64_t dstId = 0) = 0;

    /**
     * @brief 发送二进制消息到服务器
     * @param usLinkId 目标连接ID
     * @param nModuleId 模块ID，用于消息路由
     * @param nMsgID 消息ID，标识消息类型
     * @param msg 消息数据指针
     * @param nLen 消息数据长度
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param param1 自定义参数1，默认为0
     * @param param2 自定义参数2，默认为0
     * @param srcId 源ID，标识消息发送者，默认为0
     * @param dstId 目标ID，标识消息接收者，默认为0
     * 
     * @details 向服务器发送原始二进制数据：
     * - 高性能的二进制数据传输
     * - 零拷贝发送机制
     * - 精确控制数据长度
     * - 适用于大数据量传输
     * 
     * @warning 确保msg指针在发送完成前保持有效
     * @warning 确保nLen与实际数据长度一致
     */
    virtual void SendServer(uint64_t usLinkId, uint32_t nModuleId, uint32_t nMsgID, const char* msg, uint32_t nLen, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0, uint64_t srcId = 0, uint64_t dstId = 0) = 0;

    /**
     * @brief 发送Protobuf消息到服务器
     * @param usLinkId 目标连接ID
     * @param nModuleId 模块ID，用于消息路由
     * @param nMsgID 消息ID，标识消息类型
     * @param xData Protobuf消息对象
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param param1 自定义参数1，默认为0
     * @param param2 自定义参数2，默认为0
     * @param srcId 源ID，标识消息发送者，默认为0
     * @param dstId 目标ID，标识消息接收者，默认为0
     * 
     * @details 向服务器发送Protobuf格式的结构化消息：
     * - 自动序列化Protobuf消息
     * - 类型安全，编译时检查
     * - 跨语言兼容性
     * - 高效的二进制编码
     * 
     * @note 推荐用于所有结构化的服务器间通信
     */
    virtual void SendServer(uint64_t usLinkId, uint32_t nModuleId, uint32_t nMsgID, const google::protobuf::Message& xData, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0, uint64_t srcId = 0, uint64_t dstId = 0) = 0;

    /**
     * @brief 发送Protobuf消息到指定服务器
     * @param eSendType 发送方服务器类型
     * @param recvType 接收方服务器类型
     * @param srcBusId 发送方服务器Bus ID
     * @param dstBusId 接收方服务器Bus ID
     * @param nModuleId 模块ID，用于消息路由
     * @param nMsgId 消息ID，标识消息类型
     * @param xData Protobuf消息对象
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param param1 自定义参数1，默认为0
     * @param param2 自定义参数2，默认为0
     * @return 发送结果：0成功，非0值表示错误码
     * 
     * @details 服务器间的高级消息发送接口：
     * 
     * **路由特性**：
     * - 基于服务器类型的智能路由
     * - 支持跨区域服务器通信
     * - 自动服务发现和负载均衡
     * - 故障转移和重试机制
     * 
     * **应用场景**：
     * - 跨服务器的业务逻辑调用
     * - 分布式事务协调
     * - 集群状态同步
     * - 服务器间数据交换
     * 
     * @note 如果dstBusId为0，会自动选择合适的目标服务器
     * @see GetSuitServerByServerType 服务器选择算法
     */
    virtual int SendMsgToServer(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE recvType, uint32_t srcBusId, uint32_t dstBusId, uint32_t nModuleId, uint32_t nMsgId, const google::protobuf::Message& xData, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0) = 0;

    /**
     * @brief 发送字符串消息到指定服务器
     * @param eSendType 发送方服务器类型
     * @param recvType 接收方服务器类型
     * @param srcBusId 发送方服务器Bus ID
     * @param dstBusId 接收方服务器Bus ID
     * @param nModuleId 模块ID，用于消息路由
     * @param nMsgId 消息ID，标识消息类型
     * @param xData 字符串消息数据
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param param1 自定义参数1，默认为0
     * @param param2 自定义参数2，默认为0
     * @return 发送结果：0成功，非0值表示错误码
     * 
     * @details 发送字符串格式的服务器间消息：
     * - 支持文本协议和JSON格式
     * - 适用于简单的配置和状态消息
     * - 提供与Protobuf版本相同的路由能力
     * 
     * @note 对于复杂数据建议使用Protobuf版本
     */
    virtual int SendMsgToServer(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE recvType, uint32_t srcBusId, uint32_t dstBusId, uint32_t nModuleId, uint32_t nMsgId, const std::string& xData, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0) = 0;

    virtual int SendMsgToServer(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE recvType, uint32_t srcBusId, uint32_t dstBusId, uint32_t nMsgId, const google::protobuf::Message& xData, uint64_t modKey = 0, uint64_t param1 = 0, uint64_t param2 = 0)
    {
        return SendMsgToServer(eSendType, recvType, srcBusId, dstBusId, NF_MODULE_SERVER, nMsgId, xData, modKey, param1, param2);
    }

    /**
     * @brief 发送事务消息（Protobuf版本）
     * @param eSendType 发送方服务器类型
     * @param recvType 接收方服务器类型  
     * @param srcBusId 发送方服务器Bus ID
     * @param dstBusId 接收方服务器Bus ID
     * @param nMsgID 消息ID，标识消息类型
     * @param xData Protobuf消息对象
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param req_trans_id 请求事务ID，用于事务跟踪，默认为0
     * @param rsp_trans_id 响应事务ID，用于响应匹配，默认为0
     * @return 发送结果：0成功，非0值表示错误码
     * 
     * @details 发送支持事务语义的消息：
     * 
     * **事务特性**：
     * - 支持分布式事务协调
     * - 提供请求-响应的事务配对
     * - 自动事务超时和回滚机制
     * - 支持事务状态跟踪和监控
     * 
     * **事务ID说明**：
     * - req_trans_id：标识事务请求，用于事务追踪
     * - rsp_trans_id：标识事务响应，用于配对请求
     * - 支持嵌套事务和事务链
     * 
     * **使用场景**：
     * - 分布式数据库操作
     * - 跨服务器的状态同步
     * - 分布式锁和资源管理
     * - 多步骤业务流程
     * 
     * @note 事务消息需要接收方明确回应
     * @warning 事务超时可能导致自动回滚
     * @see SendMsgToServer 普通消息发送
     */
    virtual int SendTrans(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE recvType, uint32_t srcBusId, uint32_t dstBusId, uint32_t nMsgID, const google::protobuf::Message& xData, uint64_t modKey = 0, uint32_t req_trans_id = 0, uint32_t rsp_trans_id = 0) = 0;

    /**
     * @brief 发送事务消息（字符串版本）
     * @param eSendType 发送方服务器类型
     * @param recvType 接收方服务器类型
     * @param srcBusId 发送方服务器Bus ID
     * @param dstBusId 接收方服务器Bus ID
     * @param nMsgID 消息ID，标识消息类型
     * @param xData 字符串消息数据
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param req_trans_id 请求事务ID，默认为0
     * @param rsp_trans_id 响应事务ID，默认为0
     * @return 发送结果：0成功，非0值表示错误码
     * 
     * @details 发送字符串格式的事务消息：
     * - 支持文本格式的事务数据
     * - 提供与Protobuf版本相同的事务语义
     * - 适用于简单的事务协调
     * 
     * @note 对于复杂事务建议使用Protobuf版本
     */
    virtual int SendTrans(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE recvType, uint32_t srcBusId, uint32_t dstBusId, uint32_t nMsgID, const std::string& xData, uint64_t modKey = 0, uint32_t req_trans_id = 0, uint32_t rsp_trans_id = 0) = 0;

    /**
     * @brief 发送事务消息（Protobuf + 模块ID版本）
     * @param eSendType 发送方服务器类型
     * @param recvType 接收方服务器类型
     * @param srcBusId 发送方服务器Bus ID
     * @param dstBusId 接收方服务器Bus ID
     * @param moduleId 模块ID，指定处理模块
     * @param nMsgID 消息ID，标识消息类型
     * @param xData Protobuf消息对象
     * @param modKey 路由键，用于负载均衡，默认为0
     * @param req_trans_id 请求事务ID，默认为0
     * @param rsp_trans_id 响应事务ID，默认为0
     * @return 发送结果：0成功，非0值表示错误码
     * 
     * @details 支持模块化路由的事务消息：
     * - 明确指定处理模块
     * - 支持模块级别的事务管理
     * - 提供更精确的消息路由
     * - 适用于复杂的多模块事务
     * 
     * @note moduleId用于精确路由到特定模块
     */
    virtual int SendTrans(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE recvType, uint32_t srcBusId, uint32_t dstBusId, uint32_t moduleId, uint32_t nMsgID, const google::protobuf::Message& xData, uint64_t modKey = 0, uint32_t req_trans_id = 0, uint32_t rsp_trans_id = 0) = 0;

    /**
     * @brief 发送事务消息（字符串 + 模块ID版本）
     * @param eSendType 发送方服务器类型
     * @param recvType 接收方服务器类型
     * @param srcBusId 发送方服务器Bus ID
     * @param dstBusId 接收方服务器Bus ID
     * @param moduleId 模块ID，指定处理模块
     * @param nMsgID 消息ID，标识消息类型
     * @param xData 字符串消息数据
     * @param modKey 路由键，用于负载均衡
     * @param req_trans_id 请求事务ID，默认为0
     * @param rsp_trans_id 响应事务ID，默认为0
     * @return 发送结果：0成功，非0值表示错误码
     * 
     * @details 支持模块化路由的字符串事务消息：
     * - 结合模块路由和字符串数据
     * - 适用于简单的模块化事务
     * 
     * @note 提供完整的事务和路由控制
     */
    virtual int SendTrans(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE recvType, uint32_t srcBusId, uint32_t dstBusId, uint32_t moduleId, uint32_t nMsgID, const std::string& xData, uint64_t modKey, uint32_t req_trans_id = 0, uint32_t rsp_trans_id = 0) = 0;

    /**
     * @brief 根据服务器ID获取服务器数据
     * @param eSendType 发起查询的服务器类型
     * @param busId 目标服务器的Bus ID
     * @return 服务器数据的智能指针，未找到时返回nullptr
     * 
     * @details 通过服务器Bus ID精确查找服务器实例：
     * - 快速O(1)查找，基于哈希表实现
     * - 返回完整的服务器配置和状态信息
     * - 包含服务器的连接状态、负载信息等
     * - 支持动态服务器发现和注册
     * 
     * @note Bus ID是服务器在集群中的唯一标识符
     * @see CreateServerByServerId 创建服务器实例
     */
    virtual NF_SHARE_PTR<NFServerData> GetServerByServerId(NF_SERVER_TYPE eSendType, uint32_t busId) = 0;

    /**
     * @brief 根据连接ID获取服务器数据
     * @param eSendType 发起查询的服务器类型
     * @param unlinkId 网络连接ID
     * @return 服务器数据的智能指针，未找到时返回nullptr
     * 
     * @details 通过网络连接ID查找对应的服务器实例：
     * - 用于确定消息来源的服务器身份
     * - 支持连接复用和多路复用场景
     * - 提供连接到服务器的映射关系
     * - 用于连接管理和故障诊断
     * 
     * @note 连接ID是网络层分配的唯一标识符
     * @see GetServerByServerId 通过Bus ID查询
     */
    virtual NF_SHARE_PTR<NFServerData> GetServerByUnlinkId(NF_SERVER_TYPE eSendType, uint64_t unlinkId) = 0;

    /**
     * @brief 创建新的服务器实例
     * @param eSendType 发起创建的服务器类型
     * @param busId 新服务器的Bus ID
     * @param busServerType 新服务器的类型
     * @param data 服务器信息报告，包含配置和状态
     * @return 创建的服务器数据智能指针
     * 
     * @details 在集群中注册新的服务器实例：
     * - 动态服务器发现和注册机制
     * - 自动更新集群拓扑结构
     * - 初始化服务器的路由和负载均衡配置
     * - 触发服务器上线事件通知
     * 
     * @note 通常在服务器启动时自动调用
     * @warning 确保Bus ID在集群中唯一
     */
    virtual NF_SHARE_PTR<NFServerData> CreateServerByServerId(NF_SERVER_TYPE eSendType, uint32_t busId, NF_SERVER_TYPE busServerType, const NFrame::ServerInfoReport& data) = 0;

    /**
     * @brief 为服务器创建网络连接
     * @param eSendType 发起连接的服务器类型
     * @param busId 目标服务器Bus ID
     * @param linkId 网络连接ID
     * 
     * @details 建立服务器间的网络连接映射：
     * - 将网络连接与特定服务器关联
     * - 用于消息路由和负载分发
     * - 支持连接的动态管理和监控
     * - 维护服务器连接状态信息
     * 
     * @note 连接建立后会自动调用此方法
     * @see DelServerLink 删除服务器连接
     */
    virtual void CreateLinkToServer(NF_SERVER_TYPE eSendType, uint32_t busId, uint64_t linkId) = 0;

    /**
     * @brief 删除服务器连接
     * @param eSendType 发起删除的服务器类型
     * @param linkId 要删除的连接ID
     * 
     * @details 清理服务器连接相关的资源：
     * - 移除连接到服务器的映射关系
     * - 更新服务器连接状态
     * - 触发连接断开事件
     * - 清理相关的路由信息
     * 
     * @note 连接断开时会自动调用此方法
     * @see CreateLinkToServer 创建服务器连接
     */
    virtual void DelServerLink(NF_SERVER_TYPE eSendType, uint64_t linkId) = 0;

    /**
     * @brief 获取路由服务器数据
     * @param eSendType 查询的服务器类型
     * @return 路由服务器数据指针，未找到时返回nullptr
     * 
     * @details 获取负责消息路由的服务器信息：
     * - 路由服务器负责跨区域消息转发
     * - 提供服务发现和负载均衡功能
     * - 维护全局服务器拓扑信息
     * - 支持多级路由和分层架构
     * 
     * @note 每个服务器类型通常有对应的路由服务器
     * @see GetMasterData 获取主服务器数据
     */
    virtual NFServerData* GetRouteData(NF_SERVER_TYPE eSendType) = 0;

    /**
     * @brief 获取路由服务器数据（只读版本）
     * @param eSendType 查询的服务器类型
     * @return 路由服务器数据常量指针，未找到时返回nullptr
     * 
     * @details 只读方式获取路由服务器信息，用于查询操作
     * 
     * @note 只读版本保证不会修改服务器数据
     */
    virtual const NFServerData* GetRouteData(NF_SERVER_TYPE eSendType) const = 0;

    /**
     * @brief 获取主服务器数据
     * @param eSendType 查询的服务器类型
     * @return 主服务器数据指针，未找到时返回nullptr
     * 
     * @details 获取集群主控服务器信息：
     * - 主服务器负责集群管理和配置分发
     * - 处理服务器注册和心跳监控
     * - 维护全局状态和协调服务
     * - 提供集群级别的决策和控制
     * 
     * @note 主服务器通常是集群中的核心节点
     * @see GetRouteData 获取路由服务器数据
     */
    virtual NFServerData* GetMasterData(NF_SERVER_TYPE eSendType) = 0;

    /**
     * @brief 获取主服务器数据（只读版本）
     * @param eSendType 查询的服务器类型
     * @return 主服务器数据常量指针，未找到时返回nullptr
     * 
     * @details 只读方式获取主服务器信息，用于查询操作
     * 
     * @note 只读版本保证不会修改服务器数据
     */
    virtual const NFServerData* GetMasterData(NF_SERVER_TYPE eSendType) const = 0;

    /**
     * @brief 关闭指定服务器类型的所有连接
     * @param eSendType 要关闭连接的服务器类型
     * 
     * @details 批量关闭服务器的所有网络连接：
     * - 关闭该服务器类型的所有客户端连接
     * - 关闭到其他服务器的连接
     * - 清理相关的路由和状态信息
     * - 触发批量断开事件通知
     * 
     * @note 通常在服务器关闭或重启时调用
     * @warning 操作不可逆，会中断所有相关的网络通信
     * @see CloseLinkId 关闭单个连接
     */
    virtual void CloseAllLink(NF_SERVER_TYPE eSendType) = 0;

    /**
     * @brief 获取服务器连接ID
     * @param eSendType 查询的服务器类型
     * @return 服务器连接ID，未连接时返回0
     * 
     * @details 获取作为服务器监听时的连接标识：
     * - 表示该服务器的监听端口连接
     * - 用于标识服务器的网络身份
     * - 与客户端连接ID区分开来
     * - 用于服务器间的身份识别
     * 
     * @note 服务器连接ID在服务器启动时分配
     * @see SetServerLinkId 设置服务器连接ID
     */
    virtual uint64_t GetServerLinkId(NF_SERVER_TYPE eSendType) const = 0;

    /**
     * @brief 设置服务器连接ID
     * @param eSendType 目标服务器类型
     * @param linkId 要设置的连接ID
     * 
     * @details 设置服务器的监听连接标识：
     * - 在服务器绑定端口成功后调用
     * - 建立服务器类型与连接ID的映射
     * - 用于后续的连接管理和路由
     * - 确保服务器身份的唯一性
     * 
     * @note 通常在BindServer成功后自动调用
     * @see GetServerLinkId 获取服务器连接ID
     */
    virtual void SetServerLinkId(NF_SERVER_TYPE eSendType, uint64_t linkId) = 0;

    /**
     * @brief 获取客户端连接ID
     * @param eSendType 查询的服务器类型
     * @return 客户端连接ID，未连接时返回0
     * 
     * @details 获取作为客户端连接时的连接标识：
     * - 表示该服务器作为客户端的连接
     * - 用于向其他服务器发送消息
     * - 与服务器连接ID区分开来
     * - 支持双向通信模式
     * 
     * @note 客户端连接ID在ConnectServer成功后分配
     * @see SetClientLinkId 设置客户端连接ID
     */
    virtual uint64_t GetClientLinkId(NF_SERVER_TYPE eSendType) const = 0;
    virtual uint64_t GetClientUdpLinkId(NF_SERVER_TYPE eSendType) const = 0;

    /**
     * @brief 设置客户端连接ID
     * @param eSendType 目标服务器类型
     * @param linkId 要设置的连接ID
     * 
     * @details 设置客户端连接的标识：
     * - 在连接到其他服务器成功后调用
     * - 建立服务器类型与客户端连接的映射
     * - 用于消息发送和连接管理
     * - 支持服务器的客户端角色
     * 
     * @note 通常在ConnectServer成功后自动调用
     * @see GetClientLinkId 获取客户端连接ID
     */
    virtual void SetClientLinkId(NF_SERVER_TYPE eSendType, uint64_t linkId) = 0;
    virtual void SetClientUdpLinkId(NF_SERVER_TYPE eSendType, uint64_t linkId) = 0;

    /**
     * @brief 根据服务器类型获取所有服务器列表
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @return 服务器数据列表，可能为空
     * 
     * @details 获取指定类型的所有可用服务器：
     * - 返回该类型的所有在线服务器实例
     * - 用于负载分析和状态监控
     * - 支持批量操作和广播消息
     * - 包含服务器的完整状态信息
     * 
     * @note 返回的列表按服务器Bus ID排序
     * @see GetFirstServerByServerType 获取第一个服务器
     */
    virtual std::vector<NF_SHARE_PTR<NFServerData>> GetServerByServerType(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes) = 0;

    /**
     * @brief 根据服务器类型获取第一个服务器
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @return 第一个可用的服务器数据，未找到时返回nullptr
     * 
     * @details 获取指定类型的第一个可用服务器：
     * - 简单的负载均衡策略
     * - 优先选择Bus ID最小的服务器
     * - 适用于不需要复杂路由的场景
     * - 快速获取可用服务器实例
     * 
     * @note 通常用于简单的服务器选择
     * @see GetRandomServerByServerType 随机选择服务器
     */
    virtual NF_SHARE_PTR<NFServerData> GetFirstServerByServerType(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes) = 0;

    /**
     * @brief 根据服务器类型获取第一个服务器（支持跨服务器）
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @param crossServer 是否允许跨服务器选择
     * @return 第一个可用的服务器数据，未找到时返回nullptr
     * 
     * @details 获取服务器实例，支持跨区域选择：
     * - crossServer=true：可以选择其他区域的服务器
     * - crossServer=false：只选择本区域的服务器
     * - 用于控制服务器选择范围
     * - 支持分区和区域隔离
     * 
     * @note 跨服务器选择可能增加网络延迟
     */
    virtual NF_SHARE_PTR<NFServerData> GetFirstServerByServerType(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes, bool crossServer) = 0;

    /**
     * @brief 随机选择指定类型的服务器
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @return 随机选择的服务器数据，未找到时返回nullptr
     * 
     * @details 使用随机算法选择服务器：
     * - 简单的负载均衡策略
     * - 平均分布请求到各个服务器
     * - 避免热点服务器过载
     * - 提供基本的负载分散效果
     * 
     * @note 适用于无状态的服务请求
     * @see GetSuitServerByServerType 基于哈希的服务器选择
     */
    virtual NF_SHARE_PTR<NFServerData> GetRandomServerByServerType(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes) = 0;

    /**
     * @brief 随机选择指定类型的服务器（支持跨服务器）
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @param crossServer 是否允许跨服务器选择
     * @return 随机选择的服务器数据，未找到时返回nullptr
     * 
     * @details 随机选择服务器，支持跨区域：
     * - 结合随机算法和区域控制
     * - 平衡负载和网络延迟
     * - 灵活的服务器选择策略
     * 
     * @note 跨服务器选择需要考虑网络拓扑
     */
    virtual NF_SHARE_PTR<NFServerData> GetRandomServerByServerType(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes, bool crossServer) = 0;

    /**
     * @brief 基于数值哈希选择合适的服务器
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @param value 哈希值（如用户ID、房间ID等）
     * @return 选择的服务器数据，未找到时返回nullptr
     * 
     * @details 使用一致性哈希算法选择服务器：
     * - 基于value计算哈希值
     * - 确保相同value总是路由到同一服务器
     * - 支持有状态的服务器选择
     * - 提供数据亲和性和会话保持
     * 
     * @note 适用于有状态的服务，如用户会话、游戏房间等
     * @see GetRandomServerByServerType 随机选择服务器
     */
    virtual NF_SHARE_PTR<NFServerData> GetSuitServerByServerType(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes, uint64_t value) = 0;

    /**
     * @brief 基于数值哈希选择合适的服务器（支持跨服务器）
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @param value 哈希值
     * @param crossServer 是否允许跨服务器选择
     * @return 选择的服务器数据，未找到时返回nullptr
     * 
     * @details 一致性哈希选择服务器，支持跨区域：
     * - 结合哈希算法和区域控制
     * - 保持数据亲和性的同时考虑网络因素
     * - 灵活的负载均衡策略
     */
    virtual NF_SHARE_PTR<NFServerData> GetSuitServerByServerType(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes, uint64_t value, bool crossServer) = 0;

    /**
     * @brief 基于字符串哈希选择合适的服务器
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @param value 哈希字符串（如用户名、区域名等）
     * @return 选择的服务器数据，未找到时返回nullptr
     * 
     * @details 使用字符串哈希算法选择服务器：
     * - 基于字符串value计算哈希值
     * - 支持字符串类型的路由键
     * - 确保相同字符串总是路由到同一服务器
     * - 适用于基于名称的服务器选择
     * 
     * @note 字符串哈希提供了更灵活的路由策略
     */
    virtual NF_SHARE_PTR<NFServerData> GetSuitServerByServerType(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes, const std::string& value) = 0;

    /**
     * @brief 基于字符串哈希选择合适的服务器（支持跨服务器）
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @param value 哈希字符串
     * @param crossServer 是否允许跨服务器选择
     * @return 选择的服务器数据，未找到时返回nullptr
     * 
     * @details 字符串哈希选择服务器，支持跨区域：
     * - 字符串哈希与区域控制的结合
     * - 基于名称的智能路由
     * - 灵活的服务器选择策略
     */
    virtual NF_SHARE_PTR<NFServerData> GetSuitServerByServerType(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes, const std::string& value, bool crossServer) = 0;

    /**
     * @brief 获取所有服务器列表
     * @param eSendType 发起查询的服务器类型
     * @return 所有可用服务器的列表
     * 
     * @details 获取集群中所有在线的服务器实例：
     * - 包含所有类型的服务器
     * - 用于集群监控和管理
     * - 提供完整的集群拓扑视图
     * - 支持服务器状态分析
     * 
     * @note 返回的列表按服务器类型和Bus ID排序
     * @see GetAllServer 按类型筛选的版本
     */
    virtual std::vector<NF_SHARE_PTR<NFServerData>> GetAllServer(NF_SERVER_TYPE eSendType) = 0;

    /**
     * @brief 获取指定类型的所有服务器
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @return 指定类型的所有服务器列表
     * 
     * @details 获取特定类型的所有在线服务器：
     * - 按服务器类型过滤
     * - 用于类型化的服务器管理
     * - 支持负载分析和监控
     * - 提供类型级别的集群视图
     * 
     * @note 只返回指定类型的服务器实例
     */
    virtual std::vector<NF_SHARE_PTR<NFServerData>> GetAllServer(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes) = 0;

    /**
     * @brief 获取指定类型的所有服务器（支持跨服务器）
     * @param eSendType 发起查询的服务器类型
     * @param serverTypes 目标服务器类型
     * @param isCrossServer 是否包含跨服务器区域的服务器
     * @return 服务器列表
     * 
     * @details 获取服务器列表，支持区域控制：
     * - isCrossServer=true：包含所有区域的服务器
     * - isCrossServer=false：只包含本区域的服务器
     * - 用于区域化的服务器管理
     * - 支持分区和隔离策略
     */
    virtual std::vector<NF_SHARE_PTR<NFServerData>> GetAllServer(NF_SERVER_TYPE eSendType, NF_SERVER_TYPE serverTypes, bool isCrossServer) = 0;

    /**
     * @brief 获取所有数据库名称列表
     * @param eSendType 发起查询的服务器类型
     * @return 数据库名称列表
     * 
     * @details 获取集群中配置的所有数据库名称：
     * - 用于数据库管理和监控
     * - 支持动态数据库发现
     * - 提供数据库配置验证
     * - 用于数据库路由和分片
     * 
     * @note 返回去重后的数据库名称列表
     * @see GetSuitDbServer 数据库服务器选择
     */
    virtual std::vector<std::string> GetDBNames(NF_SERVER_TYPE eSendType) = 0;

    /**
     * @brief 获取模块的所有消息ID列表
     * @param eSendType 发起查询的服务器类型
     * @param moduleId 模块ID
     * @return 消息ID集合
     * 
     * @details 获取指定模块注册的所有消息ID：
     * - 用于消息路由验证
     * - 支持模块能力发现
     * - 提供消息兼容性检查
     * - 用于调试和监控
     * 
     * @note 返回的是已注册的消息ID集合
     * @see AddMessageCallBack 消息注册接口
     */
    virtual std::set<uint32_t> GetAllMsg(NF_SERVER_TYPE eSendType, uint32_t moduleId) = 0;

    /**
     * @brief 获取指定数据库的第一个服务器
     * @param eSendType 发起查询的服务器类型
     * @param dbName 数据库名称
     * @return 数据库服务器数据，未找到时返回nullptr
     * 
     * @details 获取处理指定数据库的第一个可用服务器：
     * - 简单的数据库服务器选择策略
     * - 优先选择负载较低的服务器
     * - 适用于不需要复杂路由的数据库操作
     * - 快速获取可用的数据库连接
     * 
     * @note 通常用于简单的数据库查询
     * @see GetSuitDbServer 基于哈希的数据库服务器选择
     */
    virtual NF_SHARE_PTR<NFServerData> GetFirstDbServer(NF_SERVER_TYPE eSendType, const std::string& dbName) = 0;

    /**
     * @brief 随机选择指定数据库的服务器
     * @param eSendType 发起查询的服务器类型
     * @param dbName 数据库名称
     * @return 随机选择的数据库服务器数据，未找到时返回nullptr
     * 
     * @details 使用随机算法选择数据库服务器：
     * - 简单的数据库负载均衡策略
     * - 平均分布数据库访问请求
     * - 避免数据库热点问题
     * - 提供基本的负载分散效果
     * 
     * @note 适用于无状态的数据库操作
     * @warning 函数名中有拼写错误（GeRandom应为GetRandom）
     */
    virtual NF_SHARE_PTR<NFServerData> GeRandomDbServer(NF_SERVER_TYPE eSendType, const std::string& dbName) = 0;

    /**
     * @brief 基于数值哈希选择合适的数据库服务器
     * @param eSendType 发起查询的服务器类型
     * @param dbName 数据库名称
     * @param value 哈希值（如用户ID、业务ID等）
     * @return 选择的数据库服务器数据，未找到时返回nullptr
     * 
     * @details 使用一致性哈希算法选择数据库服务器：
     * - 基于value计算哈希值进行路由
     * - 确保相同value总是路由到同一数据库服务器
     * - 支持数据分片和亲和性
     * - 提供会话保持和数据一致性
     * 
     * @note 适用于需要数据亲和性的数据库操作
     * @see GetSuitDbServer 字符串版本
     */
    virtual NF_SHARE_PTR<NFServerData> GetSuitDbServer(NF_SERVER_TYPE eSendType, const std::string& dbName, uint64_t value) = 0;

    /**
     * @brief 基于字符串哈希选择合适的数据库服务器
     * @param eSendType 发起查询的服务器类型
     * @param dbName 数据库名称
     * @param value 哈希字符串（如用户名、业务标识等）
     * @return 选择的数据库服务器数据，未找到时返回nullptr
     * 
     * @details 使用字符串哈希算法选择数据库服务器：
     * - 基于字符串value计算哈希值
     * - 支持字符串类型的数据库路由键
     * - 确保相同字符串总是路由到同一数据库服务器
     * - 适用于基于名称的数据库分片
     * 
     * @note 字符串哈希提供了更灵活的数据库路由策略
     */
    virtual NF_SHARE_PTR<NFServerData> GetSuitDbServer(NF_SERVER_TYPE eSendType, const std::string& dbName, const std::string& value) = 0;

    /**
     * @brief 随机选择一个路由服务器
     *
     * 根据指定的服务器类型和分区 ID，从可用的路由服务器中随机选择一个。
     *
     * @param eSendType 发起查询的服务器类型
     * @param zoneId 分区 ID，用于限定路由服务器的范围
     * @return NF_SHARE_PTR<NFServerData> 返回随机选择的路由服务器数据智能指针，未找到时返回 nullptr
     *
     * @note 此方法适用于无状态的路由选择场景。
     */
    virtual NF_SHARE_PTR<NFServerData> GetRandomRouteServer(NF_SERVER_TYPE eSendType, uint32_t zoneId) = 0;

    /**
     * @brief 基于数值哈希选择合适的路由服务器
     *
     * 根据指定的服务器类型、分区 ID 和哈希值，选择一个最适合的路由服务器。
     *
     * @param eSendType 发起查询的服务器类型
     * @param zoneId 分区 ID，用于限定路由服务器的范围
     * @param value 哈希值（如用户 ID、房间 ID 等），用于路由选择
     * @return NF_SHARE_PTR<NFServerData> 返回选择的路由服务器数据智能指针，未找到时返回 nullptr
     *
     * @note 使用一致性哈希算法确保相同的哈希值总是路由到同一服务器。
     */
    virtual NF_SHARE_PTR<NFServerData> GetSuitRouteServer(NF_SERVER_TYPE eSendType, uint32_t zoneId, uint64_t value) = 0;

public:
    // ========================================================================
    // 事件广播系统 - 服务器间事件通信
    // ========================================================================

    /**
     * @brief 向指定服务器广播事件
     * @param eType 发送方服务器类型
     * @param recvType 接收方服务器类型
     * @param dstBusId 目标服务器Bus ID，指定特定的服务器实例
     * @param nEventID 事件ID，唯一标识事件类型
     * @param bySrcType 事件源类型，标识事件发起者的类型
     * @param nSrcID 事件源ID，标识具体的事件发起者（如玩家ID、实体ID）
     * @param message 事件消息数据，包含事件的详细信息
     * @return 广播结果：0成功，非0值表示错误码
     * 
     * @details 向特定服务器实例广播事件：
     * 
     * **事件系统特点**：
     * - 异步事件传递，不阻塞发送者
     * - 类型安全的事件消息
     * - 支持事件链和级联处理
     * - 提供事件追踪和日志记录
     * 
     * **使用场景**：
     * - 玩家状态变更通知
     * - 游戏世界事件同步
     * - 系统状态变化通知
     * - 跨服务器的业务事件
     * 
     * **事件流程**：
     * 1. 事件封装和序列化
     * 2. 路由到目标服务器
     * 3. 触发事件处理器
     * 4. 可选的事件响应和回调
     * 
     * @note 事件广播是异步的，不保证立即处理
     * @warning 避免事件循环依赖，可能导致无限递归
     * @see BroadcastEventToAllServer 向所有服务器广播事件
     */
    virtual int BroadcastEventToServer(NF_SERVER_TYPE eType, NF_SERVER_TYPE recvType, uint32_t dstBusId, uint32_t nEventID, uint32_t bySrcType, uint64_t nSrcID, const google::protobuf::Message& message) = 0;

    /**
     * @brief 向指定类型的所有服务器广播事件
     * @param eType 发送方服务器类型
     * @param recvType 接收方服务器类型
     * @param nEventID 事件ID，唯一标识事件类型
     * @param bySrcType 事件源类型，标识事件发起者的类型
     * @param nSrcID 事件源ID，标识具体的事件发起者
     * @param message 事件消息数据
     * @return 广播结果：0成功，非0值表示错误码
     * 
     * @details 向指定类型的所有在线服务器广播事件：
     * 
     * **批量广播特点**：
     * - 自动发现目标类型的所有服务器
     * - 并行发送，提高效率
     * - 容错处理，部分失败不影响整体
     * - 支持负载均衡和故障转移
     * 
     * **适用场景**：
     * - 全服公告和通知
     * - 系统维护消息
     * - 全局配置更新
     * - 集群状态同步
     * 
     * @note 会自动过滤离线或不可达的服务器
     * @warning 大量服务器时要注意网络负载
     */
    virtual int BroadcastEventToServer(NF_SERVER_TYPE eType, NF_SERVER_TYPE recvType, uint32_t nEventID, uint32_t bySrcType, uint64_t nSrcID, const google::protobuf::Message& message) = 0;

    /**
     * @brief 向所有服务器广播事件
     * @param eType 发送方服务器类型
     * @param nEventID 事件ID，唯一标识事件类型
     * @param bySrcType 事件源类型，标识事件发起者的类型
     * @param nSrcID 事件源ID，标识具体的事件发起者
     * @param message 事件消息数据
     * @return 广播结果：0成功，非0值表示错误码
     * 
     * @details 向集群中的所有服务器广播事件：
     * 
     * **全集群广播**：
     * - 覆盖所有类型的所有服务器
     * - 最大化的事件传播范围
     * - 适用于集群级别的重要事件
     * - 支持事件优先级和过滤
     * 
     * **典型应用**：
     * - 系统紧急停机通知
     * - 全服活动开始/结束
     * - 安全警报和异常事件
     * - 集群配置热更新
     * 
     * **性能考虑**：
     * - 网络带宽消耗较大
     * - 处理延迟可能不一致
     * - 建议控制广播频率
     * 
     * @warning 慎用此接口，避免网络风暴
     * @note 某些服务器类型可能会忽略特定事件
     */
    virtual int BroadcastEventToAllServer(NF_SERVER_TYPE eType, uint32_t nEventID, uint32_t bySrcType, uint64_t nSrcID, const google::protobuf::Message& message) = 0;

    /**
     * @brief 向所有服务器广播事件（指定发送者Bus ID）
     * @param eType 发送方服务器类型
     * @param busId 发送方服务器Bus ID
     * @param nEventID 事件ID，唯一标识事件类型
     * @param bySrcType 事件源类型，标识事件发起者的类型
     * @param nSrcID 事件源ID，标识具体的事件发起者
     * @param message 事件消息数据
     * @return 广播结果：0成功，非0值表示错误码
     * 
     * @details 带发送者身份的全集群事件广播：
     * 
     * **身份标识**：
     * - 明确标识事件发送者的Bus ID
     * - 支持事件追踪和审计
     * - 便于问题定位和分析
     * - 提供完整的事件上下文
     * 
     * **安全特性**：
     * - 防止事件伪造和欺骗
     * - 支持基于发送者的权限验证
     * - 提供事件签名和验证
     * 
     * @note busId用于标识具体的发送者实例
     * @see BroadcastEventToAllServer 不指定Bus ID的版本
     */
    virtual int BroadcastEventToAllServer(NF_SERVER_TYPE eType, uint32_t busId, uint32_t nEventID, uint32_t bySrcType, uint64_t nSrcID, const google::protobuf::Message& message) = 0;

public:
    /**
     * @brief 响应HTTP请求
     * @param serverType 服务器类型
     * @param req HTTP请求处理句柄，包含请求的完整信息
     * @param strMsg 响应消息内容
     * @param code HTTP状态码，默认为200 OK
     * @param reason HTTP状态原因短语，默认为"OK"
     * @return 响应成功返回true，失败返回false
     * 
     * @details 向客户端发送HTTP响应：
     * - 自动设置响应头部信息
     * - 支持各种HTTP状态码
     * - 自动处理内容长度和编码
     * - 支持Keep-Alive连接复用
     * 
     * @note 通常在HTTP请求处理器中调用
     * @see AddHttpRequestHandler 注册HTTP请求处理器
     */
    virtual bool ResponseHttpMsg(NF_SERVER_TYPE serverType, const NFIHttpHandle& req, const std::string& strMsg, NFWebStatus code = NFWebStatus::WEB_OK, const std::string& reason = "OK") = 0;

    /**
     * @brief 响应HTTP请求（通过请求ID）
     * @param serverType 服务器类型
     * @param requestId HTTP请求的唯一标识符
     * @param strMsg 响应消息内容
     * @param code HTTP状态码，默认为200 OK
     * @param reason HTTP状态原因短语，默认为"OK"
     * @return 响应成功返回true，失败返回false
     * 
     * @details 通过请求ID响应HTTP请求：
     * - 适用于异步HTTP处理场景
     * - 支持跨线程和跨模块的响应
     * - 自动查找对应的请求上下文
     * 
     * @note 主要用于异步HTTP处理流程
     */
    virtual bool ResponseHttpMsg(NF_SERVER_TYPE serverType, uint64_t requestId, const std::string& strMsg, NFWebStatus code = NFWebStatus::WEB_OK, const std::string& reason = "OK") = 0;

    /**
     * @brief 发起HTTP GET请求
     * @param serverType 发起请求的服务器类型
     * @param strUri 目标URI地址（完整URL）
     * @param respone 响应回调函数，处理HTTP响应结果
     * @param xHeaders HTTP请求头部信息，默认为空
     * @param timeout 请求超时时间（秒），默认3秒
     * @return 请求发起成功返回0，失败返回错误码
     * 
     * @details 发起异步HTTP GET请求：
     * - 支持HTTPS安全连接
     * - 自动处理重定向
     * - 支持自定义请求头
     * - 连接池复用，提高性能
     * - 自动解压缩响应内容
     * 
     * @note 响应通过回调函数异步返回
     * @see HttpPost HTTP POST请求
     */
    virtual int HttpGet(NF_SERVER_TYPE serverType, const std::string& strUri, const HTTP_CLIENT_RESPONE& respone, const std::map<std::string, std::string>& xHeaders = std::map<std::string, std::string>(), int timeout = 3) = 0;

    /**
     * @brief 发起HTTP POST请求
     * @param serverType 发起请求的服务器类型
     * @param strUri 目标URI地址（完整URL）
     * @param strPostData POST请求的数据内容
     * @param respone 响应回调函数，处理HTTP响应结果
     * @param xHeaders HTTP请求头部信息，默认为空
     * @param timeout 请求超时时间（秒），默认3秒
     * @return 请求发起成功返回0，失败返回错误码
     * 
     * @details 发起异步HTTP POST请求：
     * - 支持各种内容类型（JSON、XML、表单等）
     * - 自动设置Content-Length头部
     * - 支持文件上传和二进制数据
     * - 自动处理字符编码
     * 
     * @note 常用于RESTful API调用和第三方服务集成
     * @see HttpGet HTTP GET请求
     */
    virtual int HttpPost(NF_SERVER_TYPE serverType, const std::string& strUri, const std::string& strPostData, const HTTP_CLIENT_RESPONE& respone, const std::map<std::string, std::string>& xHeaders = std::map<std::string, std::string>(), int timeout = 3) = 0;

    /**
     * @brief 发送邮件通知
     * @param serverType 发送邮件的服务器类型
     * @param title 邮件标题
     * @param subject 邮件主题
     * @param content 邮件内容
     * @return 发送结果：0成功，其他值表示错误码
     * 
     * @details 发送邮件通知功能：
     * - 支持HTML和纯文本格式
     * - 自动配置SMTP服务器
     * - 支持多收件人和抄送
     * - 异步发送，不阻塞主线程
     * 
     * @note 需要预先配置邮件服务器信息
     * @note 主要用于系统告警和重要事件通知
     */
    virtual int SendEmail(NF_SERVER_TYPE serverType, const std::string& title, const std::string& subject, const string& content) = 0;

    /**
     * @brief 发送企业微信消息
     * @param serverType 发送消息的服务器类型
     * @param content 消息内容
     * @return 发送结果：0成功，其他值表示错误码
     * 
     * @details 发送企业微信群消息：
     * - 支持文本、Markdown格式
     * - 自动处理消息格式和编码
     * - 支持@指定用户
     * - 异步发送机制
     * 
     * @note 需要预先配置企业微信机器人webhook
     * @note 主要用于运维告警和团队协作
     */
    virtual int SendWxWork(NF_SERVER_TYPE serverType, const string& content) = 0;

public:
    /**
     * @brief 注册HTTP消息回调处理器
     * @param serverType 服务器类型
     * @param strCommand HTTP路径命令（如"/api/user/login"）
     * @param eRequestType HTTP请求类型（GET、POST、PUT、DELETE等）
     * @param cb 回调函数对象，处理HTTP请求
     * @return 注册成功返回true，失败返回false
     * 
     * @details 为特定HTTP路径和方法注册处理器：
     * - 支持路径参数和通配符
     * - 自动路由匹配和分发
     * - 支持RESTful API设计
     * - 提供请求预处理和后处理机制
     * 
     * @note 路径匹配区分大小写
     * @see AddHttpOtherMsgCB 注册默认处理器
     */
    virtual bool AddHttpMsgCB(NF_SERVER_TYPE serverType, const std::string& strCommand, NFHttpType eRequestType, const HTTP_RECEIVE_FUNCTOR& cb) = 0;

    /**
     * @brief 注册HTTP默认消息回调处理器
     * @param serverType 服务器类型
     * @param eRequestType HTTP请求类型
     * @param cb 回调函数对象，处理未匹配的HTTP请求
     * @return 注册成功返回true，失败返回false
     * 
     * @details 为未匹配的HTTP请求注册默认处理器：
     * - 处理404错误和未知路径
     * - 提供默认的错误响应
     * - 支持通用的请求预处理
     * 
     * @note 当没有精确匹配的路径时才会调用此处理器
     */
    virtual bool AddHttpOtherMsgCB(NF_SERVER_TYPE serverType, NFHttpType eRequestType, const HTTP_RECEIVE_FUNCTOR& cb) = 0;

    /**
     * @brief 注册HTTP过滤器回调
     * @param serverType 服务器类型
     * @param strCommand HTTP路径命令
     * @param cb 过滤器回调函数，返回值决定是否继续处理请求
     * @return 注册成功返回true，失败返回false
     * 
     * @details 为指定路径注册请求过滤器：
     * - 在请求处理器之前执行
     * - 支持身份验证和权限检查
     * - 支持请求日志和统计
     * - 可以阻止或修改请求处理流程
     * 
     * @note 过滤器按注册顺序执行
     * @note 过滤器返回非WEB_OK状态会阻止后续处理
     */
    virtual bool AddHttpFilterCB(NF_SERVER_TYPE serverType, const std::string& strCommand, const HTTP_FILTER_FUNCTOR& cb) = 0;

public:
    /**
     * @brief 删除目标模块的所有注册回调
     * @param pTarget 目标动态模块指针
     * @return 删除成功返回true，失败返回false
     * 
     * 清理指定模块注册的所有消息回调、事件回调和其他回调，
     * 用于模块卸载或重置时的资源清理。
     */
    virtual bool DelAllCallBack(NFIDynamicModule* pTarget) = 0;

    /**
     * @brief 删除指定连接的所有回调
     * @param eType 服务器类型
     * @param unLinkId 网络连接ID
     * @return 删除成功返回true，失败返回false
     * 
     * 清理指定网络连接的所有回调函数，
     * 用于连接断开时的资源清理。
     */
    virtual bool DelAllCallBack(NF_SERVER_TYPE eType, uint64_t unLinkId) = 0;

    /**
     * @brief 添加消息回调处理器（模块ID为0）
     * @param eType 服务器类型
     * @param nMsgID 消息ID
     * @param pTarget 目标模块指针
     * @param cb 回调函数对象
     * @param createCo 是否创建协程处理
     * @return 注册成功返回true，失败返回false
     * 
     * 为指定消息ID添加回调处理器，每个消息只能有一个处理函数。
     * 模块ID为0表示使用默认模块。
     */
    virtual bool AddMessageCallBack(NF_SERVER_TYPE eType, uint32_t nMsgID, NFIDynamicModule* pTarget, const NET_RECEIVE_FUNCTOR& cb, bool createCo) = 0;

    /**
     * @brief 添加模块化消息回调处理器
     * @param eType 服务器类型
     * @param nModuleId 模块ID
     * @param nMsgID 消息ID
     * @param pTarget 目标模块指针
     * @param cb 回调函数对象
     * @param createCo 是否创建协程处理
     * @return 注册成功返回true，失败返回false
     * 
     * 为指定模块ID和消息ID添加回调处理器，
     * 支持模块化的消息路由和处理。
     */
    virtual bool AddMessageCallBack(NF_SERVER_TYPE eType, uint32_t nModuleId, uint32_t nMsgID, NFIDynamicModule* pTarget, const NET_RECEIVE_FUNCTOR& cb, bool createCo) = 0;

    /**
     * @brief 添加静态消息回调处理器（模块ID为0）
     * @param eType 服务器类型
     * @param nMsgID 消息ID
     * @param cb 回调函数对象
     * @param createCo 是否创建协程处理
     * @return 注册成功返回true，失败返回false
     * 
     * 为指定消息ID添加静态回调处理器，
     * 不需要关联特定的模块对象。
     */
    virtual bool AddMessageCallBack(NF_SERVER_TYPE eType, uint32_t nMsgID, const NET_RECEIVE_FUNCTOR& cb, bool createCo) = 0;

    /**
     * @brief 添加模块化静态消息回调处理器
     * @param eType 服务器类型
     * @param nModuleId 模块ID
     * @param nMsgID 消息ID
     * @param cb 回调函数对象
     * @param createCo 是否创建协程处理
     * @return 注册成功返回true，失败返回false
     * 
     * 为指定模块ID和消息ID添加静态回调处理器，
     * 支持模块化的静态消息处理。
     */
    virtual bool AddMessageCallBack(NF_SERVER_TYPE eType, uint32_t nModuleId, uint32_t nMsgID, const NET_RECEIVE_FUNCTOR& cb, bool createCo) = 0;

    /**
     * @brief 添加其他消息的统一回调处理器
     * @param eType 服务器类型
     * @param linkId 连接ID
     * @param pTarget 目标模块指针
     * @param cb 回调函数对象
     * @param createCo 是否创建协程处理
     * @return 注册成功返回true，失败返回false
     * 
     * 为未注册过的消息添加统一处理回调函数，
     * 用于处理未知或动态消息类型。
     */
    virtual bool AddOtherCallBack(NF_SERVER_TYPE eType, uint64_t linkId, NFIDynamicModule* pTarget, const NET_RECEIVE_FUNCTOR& cb, bool createCo) = 0;

    /**
     * @brief 添加全局消息回调处理器
     * @param eType 服务器类型
     * @param pTarget 目标模块指针
     * @param cb 回调函数对象
     * @param createCo 是否创建协程处理
     * @return 注册成功返回true，失败返回false
     * 
     * 对所有消息添加统一的回调处理器。
     * 通过回调函数的返回值判断是否处理消息：
     * - 返回0：处理该消息
     * - 返回非0：不处理该消息
     */
    virtual bool AddAllMsgCallBack(NF_SERVER_TYPE eType, NFIDynamicModule* pTarget, const NET_RECEIVE_FUNCTOR& cb, bool createCo) = 0;

    /**
     * @brief 添加网络事件回调处理器
     * @param eType 服务器类型
     * @param linkId 连接ID
     * @param pTarget 目标模块指针
     * @param cb 事件回调函数对象
     * @param createCo 是否创建协程处理
     * @return 注册成功返回true，失败返回false
     * 
     * 添加连接事件和断线事件的处理函数，
     * 用于监控网络连接状态变化。
     */
    virtual bool AddEventCallBack(NF_SERVER_TYPE eType, uint64_t linkId, NFIDynamicModule* pTarget, const NET_EVENT_FUNCTOR& cb, bool createCo) = 0;
};
